移位运算
移位运算包含逻辑移位(logical shif) 和 算术移位(arithmetic shift)。
- 逻辑移位：移出去的位丢弃，空缺位用"0"填充。
- 算术移位：移出去的位丢弃，空缺位用"符号位"来填充。
左移操作
将 A 的二进制表示的整体向左移 B 位，左边超出 32 位的截掉（包括符号位），右边不足的位补 0。
int A = 12
int C = A << B // C = A * 2^B（如果不溢出）
eg：溢出
INT_MAX // 01111111 11111111 11111111 11111111(补码) = 2147483647
INT_MAX << 1 // 11111111 11111111 11111111 11111110(补码) = -2 (逻辑移位)
UINT_MAX // 11111111 11111111 11111111 11111111 = 4294967295
UINT_MAX << 1 // 11111111 11111111 11111111 11111110 = 4294967294 (逻辑移位)
右移操作
C++ 里面，右移操作和数据类型相关，无符号数是逻辑移位，有符号数是算术移位。
int A = 12
int C = A << B // C = A / 2^B
eg：
INT_MIN // 10000000 00000000 00000000 00000001(补码) = -2147483648
INT_MIN >> 1 // 11000000 00000000 00000000 00000000(补码) = -1073741824 (算术移位)
UINT_MAX // 11111111 11111111 11111111 11111111 = 4294967295
UINT_MAX >> 1 // 01111111 11111111 11111111 11111111 = 2147483647 (逻辑移位)
按位与操作 a & b
将A和B的二进制表示的每一位进行与操作，只有两个对应的二进制位都为1时，结果位才为1，否则为0。这个常用来取出某个特定的二进制位的值。
0 0 1 0 1 0
& 1 0 1 1 0 0
-------------------
0 0 1 0 0 0
按位或操作 a | b
将A和B的二进制表示的每一位进行或操作，只要两个对应的二进制位有一个为1，结果位就为1，否则为0。这个常用来将某个特定的二进制位的值置1。
0 0 1 0 1 0
| 1 0 1 1 0 0
-------------------
1 0 1 1 1 0
按位非操作 ~ a
将A的二进制表示每一位进行取反操作，如果对应的二进制位为0，结果位为1，否则为0。
0 0 1 0 1 0
~
-------------------
0 1 0 1 0 1
按位异或操作
将A和B的二进制表示的每一位进行异或操作，如果对应的二进制位不同，结果位为1，否则为0。
0 0 1 0 1 0
^ 1 0 1 1 0 0
-------------------
1 0 0 1 1 0
技巧1：不用加减乘除做加法，乘法
-
不用加减乘除做加法：计算3 +６(不考虑溢出)
3: 0 0 1 1 6: 0 1 1 0 0 0 1 1 0 0 1 1 0 1 0 1 ^ 0 1 1 0 & 0 1 1 0 + 0 1 0 0(0010 << 1) ----------------- ---------------- ---------------- 0 1 0 1(不进位) 0 0 1 0 (进位) 1 0 0 1(9) 0 1 0 1 0 1 0 1 0 0 0 1 ^ 0 1 0 0 & 0 1 0 0 + 1 0 0 0(0100 << 1) ----------------- ---------------- ---------------- 0 0 0 1(不进位) 0 1 0 0 (进位) 1 0 0 1(9) 0 0 0 1 0 0 0 1 1 0 0 1 ^ 1 0 0 0 & 1 0 0 0 + 0 0 0 0(0000 << 1) ----------------- ---------------- ---------------- 1 0 0 1(不进位) 0 0 0 0 (进位) 1 0 0 1(9)int plusWithBitOperator(int num1, int num2) { int xor_result = 0; int and_result = 0; while(num2) { xor_result = num1 ^ num2; and_result = num1 & num2; num1 = xor_result; num2 = and_result << 1; } return xor_result; } -
不用加减乘除运算符计算a = b * 9(不考虑溢出)
a = b * 9 = b*8 + b = b << 3 + b;int mulWithBitOperator(int num1){ return plusWithBitOperator(num1 << 3, num1); }
技巧2：消除二进制中最右侧的那个1
x = 1100
x - 1 = 1011
x & (x-1) = 1000
应用1：用O（1）时间检测整数n是否是2的幂次
- N如果是2的幂次，那么N满足2个条件
- N > 0
- N的二进制表示中只有1个1。
因为二进制表示中只有一个1，所以N&(N-1)将N唯一的一个1消去，应该返回0。
bool checkPowerOf2(int n)
{
return n > 0 && (n & (n-1)) == 0;
}
应用2：计算在32位整数的二进制表示中有多少个1
由x & (x - 1)消去x最后一位的1可知。不断使用 x & (x - 1) 消去x最后一位的1，计算总共消去了多少次即可。
int countBinaryOnes(int num)
{
int count = 0;
while (num != 0) {
num = num & (num - 1);
count++;
}
return count;
}
应用3：如果要将整数A转换为B，需要改变多少个bit位？
异或操作，相同为0，相异为1，所以问题转变成了计算A异或B之后这个数中1的个数。
countBinaryOnes(a ^ b);
技巧3：巧用异或运算
- 一个数同另一个数异或2次还等于它本身。
a ^ b ^ b = a
b ^ b = 0
应用1：数组中，只有一个数出现一次，剩下都出现两次，找出出现一次的数
因为只有一个数恰好出现一个，剩下的都出现过两次，所以只要将所有的数异或起来，就可以得到唯一的那个数，因为相同的数出现的两次，异或两次等价于没有任何操作！
int singleNumber(int[] nums)
{
int result = 0, n = nums.length;
for (int i = 0; i < n; i++) {
result ^= nums[i];
}
return result;
}
应用2：数组中，只有一个数出现一次，剩下都出现三次，找出出现一次的数
应用3：数组中，只有两个数出现一次，剩下都出现两次，找出出现一次的这两个数
有了第一题的基本的思路，我们可以将数组分成两个部分，每个部分里只有一个元素出现一次，其余元素都出现两次。那么使用这种方法就可以找出这两个元素了。不妨假设出现一个的两个元素是x，y，那么最终所有的元素异或的结果就是等价于res = x^y。并且res！=0
对于x和y，一定是其中一个这一位是1，另一个这一位不是1，因为如果都是0或者都是1，怎么可能异或出1
对于原来的数组，我们可以根据这个位置是不是1就可以将数组分成两个部分。x，y一定在不同的两个子集中。
先讲个小技巧
10：01010 (补码，最高位为符号位)
-10：10101(反码，正数的反码就是原码，负数的反码是符号位不变，其余位取反)
-10：10110（补码，正数的补码就是原码，负数的补码是反码+1）
n &= -n; // n中最后一位为1的位为1，其余位为0
0 1 0 1 0
& 1 0 1 1 0
----------------
0 0 0 1 0
vector<int> singleNumber(const vector<int>& vec) {
int diff = 0;
for (const auto &i : vec)
diff ^= i;
// 取出最后一位为1的位置
diff &= -diff;
vector<int> vec={0, 0};
for (int i = 0; i < nums.lenght; i++) {
if ((nums[i] & diff) == 0)
vec[0] ^= nums[i];
else
vec[1] ^= nums[i];
}
return vec;
}
不用额外空间使用异或交换2个元素
异或运算的特质：
如果a ^ b = c，那么a ^ c = b 与 b ^ c = a同时成立，利用这一条，于是交换2个变量的值有以下方法：
a = a ^ b
b = a ^ b
a = a ^ b
- 使用加减法交换2个变量值也可以达到不用额外空间交换2个变量的值
a = a + b // new_a = old_a + old_b b = a - b // new_b = new_a - old_b = old_a + old_b - old_b = old_a a = a - b // new_a = new_a - new_b = old_a + old_b - old_a
技巧4：循环队列的buffer size 为什么需要保证为2的幂？
为什么需要保证 buffer size 为2的幂？
因为通常循环队列的入队和出队操作要不断的对size进行求余， 为了提高效率，将 buffer size 扩展为2的幂，就可以使用位运算。kfifo->in % kfiifo->size 等同于 kfifo->in & (kfifo->size – 1)。
假设现在size 为16：
8 & (size - 1) = 01000 & 01111 = 01000 = 8
15 & (size -1) = 01111 & 01111 = 01111 = 15
16 & (size - 1) = 10000 & 01111 = 00000 = 0
26 & (size - 1 ) = 11010 & 01111 = 01010 = 10
所以保证size是2的幂的前提下，可以通过位运算的方式求余，在频繁操作对列的情况下可以大大提高效率。
参考资料
[1] https://www.jiuzhang.com/tutorial/bit-manipulation/75
[2] http://blog.sina.cn/dpool/blog/s/blog_bf30105b0101gk68.html
