Bit Operation on Hang Zhang

Is Unique

Thu, 17 Apr 2025 00:00:00 +0000

判断字符是否唯一

分析

用一个整型变量 check 作为位掩码（bitmask），其每一位表示一个字符是否出现
遍历字符串中的每个字符：
- 如果该字符之前出现过（对应位为 1），说明不唯一，返回 false
- 否则将对应位设为 1
遍历完成仍未发现重复，返回 true

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution {
public:
    bool isUnique(string astr)
    {
        int check = 0;  // 位掩码，初始为 0

        for (char c : astr)
        {
            // 计算字符在字母表中的索引位置（0~25）
            int bit = c - 'a';

            // 如果对应位已为 1，说明重复
            if (check & (1 << bit))
                return false;

            // 否则将该位置为 1
            check |= (1 << bit);
        }

        // 所有字符都不同
        return true;
    }
};

Bitwise and of Numbers Range

Thu, 13 Feb 2025 00:00:00 +0000

201. 数字范围按位与

分析

按位与的性质
- 任何数字与 0 进行按位与，结果都是 0，即 x & 0 = 0
- 相邻数字的按位与会减少 1 位的 1，例如：

计算 5 & 6 & 7 = 4，可以看到最右侧的 1 被清除了

观察区间变化
- 若 left 和 right 的二进制前缀相同，则它们的按位与结果保留这个前缀，后面的位全部补 0
- 若 left 和 right 的某一位出现了不同（即 0->1 或 1->0），则从该位及其更低位的按位与结果必然为 0

时间复杂度

由于整数的二进制表示最多 32 位，我们最多遍历 32 次，因此时间复杂度为 O(1)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int rangeBitwiseAnd(int left, int right)
    {
      int res = 0; // 存储最终结果
      for (int i = 30; i >= 0; -- i)  // 从高位到低位遍历每一位
      {
        if ((left >> i & 1) != (right >> i & 1))  // 如果某一位的 left 和 right 不同，终止循环
          break;
        if (left >> i & 1)  // 如果 left 在该位是 1，则保留该位
          res += (1 << i);
      }
      return res;
    }
};

Single Number II

Tue, 11 Feb 2025 00:00:00 +0000

137. 只出现一次的数字II

分析

考虑整数在计算机中以 32 位二进制形式表示，可以逐位统计数组中每个位上的 1 的出现次数

逐位遍历
- 对于每一位 i（从 0 到 31 位），统计所有数字中第 i 位上的 1 的总数 c
模 3 运算
- 若某个位上的 1 的出现次数不是 3 的倍数，则说明这个位在目标数中为 1
- 将该位加入结果 res
结果构建
- 将每一位结果通过位运算 res |= (c % 3) << i 累加到最终结果 res 中

时间复杂度

时间复杂度 O(n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    int singleNumber(vector<int>& nums)
    {
        int res = 0;
        for (int i = 0; i < 32; ++i) // 遍历每一个二进制位
        {
            int c = 0;

            // 统计当前二进制位上 1 的数量
            for (int x : nums)
                c += (x >> i) & 1;

            // 若该二进制位的 1 数量不是 3 的倍数，将该位加入结果
            res |= (c % 3) << i;
        }
        return res;
    }
};

Count Bits

Wed, 08 Jan 2025 00:00:00 +0000

338. 比特位计数

分析

状态定义
- 定义 f[i]：表示数字 i 的二进制表示中 1 的个数
状态转移
- 将数字 i 右移一位（即 i >> 1 ），相当于去掉最低位的二进制位
- 数字 i 中的 1 的个数可以表示为：f[i] = f[i >> 1] + (i & 1)
- f[i >> 1] ：前一个数字中 1 的个数
- i & 1：判断最低位是否为 1（若最低位为 1 ，加 1 ；否则加 0 ）
初始状态
- f[0] = 0 ：数字 0 的二进制表示中没有 1

时间复杂度

遍历从 1 到 n 的所有数字，动态规划计算 f[i]
每次计算的复杂度为 O(1) ，总复杂度为 O(n)

空间复杂度

空间复杂度为 O(n)

C++代码

class Solution
{
public:
    vector<int> countBits(int n)
    {
        // 定义结果数组，长度为 n + 1
        std::vector<int> f(n + 1);
        // 动态规划填充数组
        for (int i = 1; i <= n; ++i)
            // 根据状态转移方程计算
            f[i] = f[i >> 1] + (i & 1);
        return f;
    }
};

Minimum Flips To Make A or B Equal to C

Wed, 08 Jan 2025 00:00:00 +0000

1318. 或运算的最小翻转次数

分析

位运算分析
- 对每一位（从低位到高位）分别判断 a 、b 、c 的二进制表示：
- x = a >> i & 1：表示 a 的第 i 位
- y = b >> i & 1：表示 b 的第 i 位
- z = c >> i & 1：表示 c 的第 i 位
根据 z 的值，分情况讨论：
- 如果 z = 0 ：
  - 需要 x = 0 且 y = 0，因此：需要翻转的次数 = x + y
- 如果 z = 1 ：
  - 至少需要 x = 1 或 y = 1 。若 x = 0 且 y = 0 ，则需要翻转 1
循环计算

逐位处理 a 、b 和 c ，根据上述规则累加所需的翻转次数

终止条件

由于题目限制 a, b, c 小于 1e9，其最大值在 2^30 以内，因此只需处理前 30 位即可

时间复杂度

O(1)

空间复杂度

O(1)

C++代码

class Solution
{
public:
    int minFlips(int a, int b, int c)
    {
        int res = 0;
        // 遍历 30 位
        for (int i = 0; i < 30; ++i)
        {
            int x = a >> i & 1; // a 的第 i 位
            int y = b >> i & 1; // b 的第 i 位
            int z = c >> i & 1; // c 的第 i 位

            if (z == 0)  // 如果 z 为 0
                res += x + y; // 需要翻转 x 和 y 中的所有 1
            else if (!x && !y) // 如果 z 为 1 且 x 和 y 都为 0
                ++ res; // 至少需要翻转一个 0 为 1
        }
        return res; // 返回总翻转次数
    }
};

reverseBits

Sat, 23 Nov 2024 00:00:00 +0000

190. reverseBits

分析

核心步骤：取二进制数的第i位n >> i & 1

res每次左移一位，然后将n的最低位加到res上

C++代码

class Solution {
public:
    uint32_t reverseBits(uint32_t n)
    {
      uint32_t res = 0;
      for (int i = 0; i < 32; ++ i)
        res = (res << 1) + (n >> i & 1);
      return res;
    }
};