【常用算法：进阶篇】13.位运算全解析：从底层原理到高效算法

一、位运算基础：二进制世界的原子操作

1. 六大核心位运算与逻辑本质

位运算是直接操纵二进制位的底层操作，其效率接近硬件级别，是理解计算机底层逻辑的关键。以下是六大核心操作的逻辑规则与典型应用：

操作	符号	逻辑规则（以8位为例）	核心特性	典型用途	Python示例
与	&	1010 0101 & 1100 1100 = 1000 0100	同1为1，其余为0	提取特定位、清零低位	a & b
或	`	`	`1010 0101	1100 1100 = 1110 1101`	有1为1，全0为0
异或	^	1010 0101 ^ 1100 1100 = 0110 1001	不同为1，相同为0	无进位加法、状态翻转、找不同	a ^ b
取反	~	~1010 0101 = 0101 1010（补码）	逐位取反，符号位参与运算	数值取负、按位取反	~a
左移	<<	1010 << 2 = 101000	左移n位相当于×2ⁿ	快速乘法、扩大数值范围	a << n
右移	>>	1010 >> 2 = 10	右移n位相当于÷2ⁿ（向下取整）	快速除法、缩小数值范围	a >> n

关键思维：将每个二进制位视为独立的逻辑单元（0/1状态），通过位组合（如2位表示4种状态、4位表示16种状态）实现数据压缩。例如，用20位整数可记录10个数字的出现次数（每个数字用2位表示0-3次），相比传统数组节省5倍空间。

2. 数据存储革命：从字节到比特的压缩哲学

传统数据结构以字节（8位）为最小单位，而位运算直接操作比特位，实现极致空间优化：

• 位掩码（Bitmask）：用整数的每一位表示独立状态。
  案例：记录字符串中26个字母的出现情况，仅需1个整数（32位）：

  # 判断字符串是否为回文排列（不区分大小写，允许最多一个字符奇数次出现）
  def can_permute_palindrome(s):mask = 0for c in s.lower():if 'a' <= c <= 'z':mask ^= 1 << (ord(c) - ord('a'))  # 异或标记出现次数return mask == 0 or (mask & (mask - 1)) == 0  # 0或仅1位为1
  

• 位图（BitMap）：用位向量替代布尔数组，适用于海量数据去重。
  实现原理：用一个整数数组存储位集合，每个元素对应一个状态（0/未出现，1/出现）。

  class BitMap:def __init__(self, max_num):self.size = (max_num >> 5) + 1  # 每个int存储32位，计算所需数组长度self.bits = [0] * self.sizedef set(self, num):idx = num >> 5  # 确定所属int下标（num // 32）pos = num & 0x1F  # 确定在int中的位位置（num % 32）self.bits[idx] |= (1 << pos)  # 置位def exists(self, num):idx = num >> 5pos = num & 0x1Freturn (self.bits[idx] & (1 << pos)) != 0  # 检查该位是否为1
  

  应用场景：处理1亿个整数的去重问题，仅需约12MB内存（1亿/32 ≈ 3.125MB，考虑整数存储开销），相比哈希表节省90%以上空间。

二、位运算与数据结构：比特级别的高效存储

1. 状态压缩：用位组合替代多维数组

（1）素数数字组成统计（按位统计法）

问题：在4位素数中，找出由相同数字组成的素数（如9937和9973均含2个9、1个7、1个3）。
传统方案：用长度为10的数组记录每个数字出现次数，空间复杂度O(10)。
位运算优化：每个数字的出现次数（0-3次）用2位表示，10个数字共需20位（1个整数）：

// C语言实现：统计数字x的位掩码
int get_digit_mask(int x) {int mask = 0;while (x > 0) {int digit = x % 10;// 清除该数字原有的位状态（2位一组）mask &= ~(0b11 << (digit * 2));// 记录出现次数：1次→01（1<<0），2次→10（1<<1），3次→11（0b11）mask |= (1 << ((x / 10 % 10) ? 1 : 0)) << (digit * 2); // 简化示例，实际需统计次数x /= 10;}return mask;
}

优势：用整数替代数组，空间压缩5倍，配合哈希表可快速分组相同状态的素数。

（2）八皇后问题（位运算优化）

传统方案：用二维数组标记皇后位置，每次放置需检查行、列、对角线，时间复杂度O(n²)。
位运算方案：用3个整数分别记录列、主对角线、副对角线的占用状态，通过位与运算快速判断合法位置：

// C++实现：位运算优化的八皇后DFS
void solveNQueens(int n) {vector<vector<string>> res;function<void(int, int, int, int)> dfs = [&](int row, int cols, int diag1, int diag2) {if (row == n) {// 生成解res.push_back(generate_board());return;}// 计算当前行可放置的位置（~(cols | diag1 | diag2) 表示未被占用的位）int available = ~(cols | diag1 | diag2) & ((1 << n) - 1);while (available) {int pos = available & -available; // 取最低位的1（即当前可放置的列）available ^= pos; // 移除已选位置// 递归下一行，更新列、主对角线（右移1位）、副对角线（左移1位）的占用状态dfs(row + 1, cols | pos, (diag1 | pos) >> 1, (diag2 | pos) << 1);}};dfs(0, 0, 0, 0);
}

效率提升：位运算将每次位置检查从O(n)优化至O(1)，n=16时仍可高效求解，而传统方法在n=12时已明显卡顿。

2. 位向量与高级数据结构

（1）二进制索引树（Fenwick Tree）

核心原理：利用lowbit(x) = x & -x快速定位更新和查询的路径，实现O(log n)时间的前缀和更新与查询。

# Python实现：Fenwick Tree求解前缀和
class FenwickTree:def __init__(self, size):self.n = sizeself.tree = [0] * (self.n + 1)def update(self, idx, delta):  # 单点更新：将索引idx的值增加deltawhile idx <= self.n:self.tree[idx] += deltaidx += idx & -idx  # 跳转至下一个父节点def query(self, idx):  # 前缀和查询：计算[1, idx]的和res = 0while idx > 0:res += self.tree[idx]idx -= idx & -idx  # 跳转至前一个子节点return res

应用场景：数组频繁更新与前缀和查询（如动态数列统计），相比暴力法O(n)更新/查询，效率提升至O(log n)。

（2）布隆过滤器（Bloom Filter）

核心思想：用多个哈希函数将元素映射到位图的多个位置，通过位或运算标记存在性，实现近似去重。

# Python简化实现：布隆过滤器
class BloomFilter:def __init__(self, size, hash_count):self.size = sizeself.hash_count = hash_countself.bitmap = BitMap(size)  # 基于前文的BitMap类def add(self, element):for i in range(self.hash_count):hash_val = hash(element + str(i)) % self.sizeself.bitmap.set(hash_val)def might_exist(self, element):for i in range(self.hash_count):hash_val = hash(element + str(i)) % self.sizeif not self.bitmap.exists(hash_val):return Falsereturn True

优势：空间效率远超哈希表（如100万元素仅需1MB左右），但存在误判可能（可通过增加哈希函数和位图大小降低概率）。

三、位运算与算法优化：比特级别的效率革命

1. 异或（XOR）的神奇应用

（1）单一奇数次出现的数（基础版）

问题：数组中仅有一个数出现奇数次，其余数出现偶数次，求该数。
解法：利用异或的交换律和结合律，相同数异或为0，最终结果为奇数次出现的数。

// C语言实现
int find_odd(int* nums, int n) {int x = 0;for (int i = 0; i < n; i++) {x ^= nums[i]; // 异或统计奇偶性}return x;
}

扩展：若数组中有两个数出现奇数次，其余数出现偶数次，可通过异或结果的某一位1将数组分为两组，分别异或求解。

（2）非3次出现的数（进阶版）

问题：数组中仅有一个数出现1次或2次，其余数出现3次，求该数。
解法：用2位（a和b）记录每个bit位的出现次数（00=0次，01=1次，10=2次，00=3次），通过状态转移方程更新状态：

// C语言实现
int find_unique(int* nums, int n) {int a = 0, b = 0; // a为高位，b为低位，组合表示00/01/10三种状态for (int i = 0; i < n; i++) {int num = nums[i];int new_b = (~a) & (b ^ num); // 低位更新：仅当a=0时，b异或num（避免进入11状态）int new_a = a ^ num & (~new_b); // 高位更新：依赖新的b值，确保a和b不同时为1a = new_a;b = new_b;}return a | b; // 出现1次或2次的数，a或b至少一位为1
}

2. 分治思想与分组统计：快速计算二进制中1的个数

（1）传统方法：逐位清除1

# O(k)时间，k为1的个数
def count_ones_traditional(x):count = 0while x:x &= x - 1  # 清除最低位的1count += 1return count

（2）分治优化法：逐层分块累加

核心步骤：

1. 两位分组：将每2位的高位累加到低位（如10→01+1），用0x55555555（二进制0101…）和0xAAAAAAAA（1010…）提取高低位；
2. 四位分组：将每4位的高两位累加到低两位，用0x33333333（0011…）和0xCCCCCCCC（1100…）提取高低位；
3. 依此类推：直至累加成一个32位整数，结果即为1的个数。

// C语言实现：O(1)时间，仅需5次操作
int count_ones_optimized(int x) {// 两位分组累加：将每2位的1的个数存入低2位（如10→01+1→0b11→3）x = (x & 0x55555555) + ((x >> 1) & 0x55555555);// 四位分组累加：将每4位的高2位累加到低2位（如0b1010→0b0010+0b0001=3）x = (x & 0x33333333) + ((x >> 2) & 0x33333333);// 八位分组累加：将每8位的高4位累加到低4位x = (x & 0x0F0F0F0F) + ((x >> 4) & 0x0F0F0F0F);// 十六位分组累加：将每16位的高8位累加到低8位x = (x & 0x00FF00FF) + ((x >> 8) & 0x00FF00FF);// 三十二位累加：最终结果x = (x & 0x0000FFFF) + ((x >> 16) & 0x0000FFFF);return x;
}

优势：无论1的个数多少，均只需5次操作，适用于高频统计场景（如视频编码中的像素统计）。

3. 快速幂与位分解：O(log n)时间的指数运算

问题：计算a^b，传统方法时间复杂度O(b)，位运算通过分解指数为二进制位，实现O(log b)时间复杂度。

# Python实现：快速幂（递归版）
def fast_pow(a, b):if b == 0:return 1half = fast_pow(a, b >> 1)  # 递归计算a^(b//2)if b & 1:  # b为奇数，需额外乘areturn half * half * aelse:       # b为偶数，直接平方return half * half

扩展应用：矩阵快速幂（求解斐波那契数列、状态转移矩阵等），将时间复杂度从O(n)优化至O(log n)。

四、经典问题与实战：位运算的真实战场

1. 只出现一次的数字（LeetCode 136）

问题：数组中除一个数出现一次外，其余数均出现两次，找出该数。
解法：异或所有元素，利用a^a=0和a^0=a的性质。

# Python实现
def single_number(nums):result = 0for num in nums:result ^= numreturn result

2. 汉明距离（LeetCode 461）

问题：计算两个整数二进制表示中不同位的数量。
解法：异或后统计1的个数，利用x &= x-1消除最低位1。

# Python实现
def hamming_distance(x, y):xor = x ^ ycount = 0while xor:xor &= xor - 1count += 1return count

3. 子集枚举（LeetCode 78）

问题：生成数组的所有子集。
解法：用位掩码mask从0到2^n-1遍历，每位为1表示包含对应元素。

# Python实现
def subsets(nums):n = len(nums)subsets = []for mask in range(1 << n):  # 枚举所有2^n种状态subset = [nums[i] for i in range(n) if (mask >> i) & 1]subsets.append(subset)return subsets

4. 二进制反转（LeetCode 190）

问题：将32位无符号整数的二进制位反转。
解法：逐块交换高低位（先交换16位块，再交换8位块，依此类推）。

// C++实现
uint32_t reverse_bits(uint32_t n) {n = (n >> 16) | (n << 16); // 交换高16位和低16位n = ((n & 0xFF00FF00) >> 8) | ((n & 0x00FF00FF) << 8); // 交换高8位和低8位（在16位块内）n = ((n & 0xF0F0F0F0) >> 4) | ((n & 0x0F0F0F0F) << 4); // 交换高4位和低4位（在8位块内）n = ((n & 0xCCCCCCCC) >> 2) | ((n & 0x33333333) << 2); // 交换高2位和低2位（在4位块内）n = ((n & 0xAAAAAAAA) >> 1) | ((n & 0x55555555) << 1); // 交换相邻位（在2位块内）return n;
}

五、进阶技巧与注意事项

1. 状态压缩动态规划（DP）

场景：当状态为集合的子集时（如旅行商问题TSP），用位掩码表示已访问节点，降低状态空间。
示例：LeetCode 935. 骑士拨号器（计算骑士在手机键盘上移动n步的不同路径数）

# Python实现：状态压缩DP，mask表示已按数字的集合，pos表示当前位置
def knight_dialer(n):moves = {0:[4,6], 1:[6,8], 2:[7,9], 3:[4,8], 4:[0,3,9], 5:[], 6:[0,1,7], 7:[2,6], 8:[1,3], 9:[2,4]}dp = [defaultdict(int) for _ in range(n)]# 初始化：第一步按每个数字，mask为仅该数字的位掩码for i in range(10):dp[0][(1 << i, i)] = 1for step in range(1, n):for (mask, pos), cnt in dp[step-1].items():for next_pos in moves[pos]:new_mask = mask | (1 << next_pos)dp[step][(new_mask, next_pos)] = (dp[step][(new_mask, next_pos)] + cnt) % (10**9+7)return sum(dp[-1].values()) % (10**9+7)

2. 警惕符号位与语言特性

• 有符号数右移：在C/C++/Java中，>>为算术右移（保留符号位），如-1 >> 1结果为-1（二进制补码表示为全1）；在Python中同理，但可通过n & 0xFFFFFFFF转为无符号数处理。
• 位运算优先级：位运算符优先级低于比较运算符，如a & b == 0需写为(a & b) == 0。
• 大数处理：Python中整数无长度限制，但在C/C++中需注意溢出（如左移导致符号位变化）。

3. 空间与时间的权衡：避免状态爆炸

位掩码的状态数随位数呈指数级增长（n位有2ⁿ种状态），当n>20时状态数超过百万，需谨慎使用：

• 剪枝优化：在状态压缩DP中，提前跳过不可能的状态（如TSP中若当前路径长度已超过最优解，直接终止）；
• 分块处理：将大问题拆分为多个子问题，每个子问题独立处理位掩码（如将32位拆分为2个16位块）。

六、位运算核心知识点总结

技术点	核心思想	典型场景	关键代码片段	时间复杂度
位掩码状态压缩	用二进制位表示独立状态，压缩存储	权限系统、子集枚举、数独校验	`mask	= 1 << pos;`
异或唯一性检测	利用a^a=0快速找出单一奇数次元素	数组去重、数据校验	x ^= num;	O(n)
分治分组统计	按块累加二进制位，减少操作次数	高效统计1的个数、汉明距离计算	x = (x & 0x55555555) + (x >> 1 & 0x55555555);	O(1)
状态压缩DP	用位掩码表示DP状态，降低空间复杂度	旅行商问题、骑士拨号器	dp[mask][pos] = ...;	O(n·2ⁿ)
位图与布隆过滤器	用位向量实现海量数据去重	垃圾邮件过滤、数据库去重	bitmap.set(num); bitmap.exists(num);	O(1)

七、课后练习与拓展思路

1. 实战题目

1. LeetCode 191. 位1的个数：用分治分组统计法实现O(1)时间计算。
2. LeetCode 338. 比特位计数：利用动态规划dp[x] = dp[x&(x-1)] + 1批量计算。
3. LeetCode 477. 汉明距离总和：统计每一位上0和1的个数，计算贡献值。

2. 拓展任务

• 实现高性能布隆过滤器：用多个哈希函数和更大的位图降低误判率，并支持删除操作（需结合计数布隆过滤器）。
• 位运算优化排序算法：针对0-255的整数，用位图统计频率后重建数组（桶排序的位运算变种）。
• 探索量子计算中的位运算：了解量子比特（Qubit）与经典位的区别，思考异或等操作的量子实现。

八、结语：从比特到算法的思维跃迁

位运算不仅是编程技巧，更是一种“从底层视角解决问题”的思维方式。通过操纵二进制位，我们实现了：

• 空间的极致压缩：用位掩码替代数组，用位图处理海量数据；
• 时间的指数级优化：异或实现线性时间查找，分治实现常数时间统计；
• 问题的抽象转换：将复杂状态压缩为位模式，用位运算规则替代逻辑判断。

在算法竞赛和系统开发中，位运算常作为“最后一公里优化”的关键手段——例如，在游戏引擎中用位掩码管理物体状态，在数据库中用位图加速查询。掌握位运算，意味着你能在比特层面与计算机对话，让代码运行得更快、更省、更优雅。