位运算的奇技淫巧
& 与运算
两个位都是 1 时，结果才为 1，否则为 0
1 0 0 1 1
& 1 1 0 0 1
1 0 0 0 1
| 或运算
两个位都是 0 时，结果才为 0，否则为 1
1 0 0 1 1
| 1 1 0 0 1
1 1 0 1 1
可以用在if语句判断中(替代 || )
^异或运算
两个位相同则为 0，不同则为 1
1 0 0 1 1
^ 1 1 0 0 1
0 1 0 1 0
<< 左移运算
向左进行移位操作，高位丢弃，低位补 0
int a = 8;
a << 3;
移位前：0000 0000 0000 0000 0000 0000 0000 1000
移位后：0000 0000 0000 0000 0000 0000 0100 0000
>>右移运算
向右进行移位操作，对无符号数，高位补 0，对于有符号数，高位补符号位
unsigned int a = 8;
a >> 3;
移位前：0000 0000 0000 0000 0000 0000 0000 1000
移位后：0000 0000 0000 0000 0000 0000 0000 0001
int a = -8;
a >> 3;
移位前：1111 1111 1111 1111 1111 1111 1111 1000
移位前：1111 1111 1111 1111 1111 1111 1111 1111
常见位运算问题
-
位操作实现乘除法
-
数 a 向右移一位，相当于将 a 除以 2；数 a 向左移一位，相当于将 a 乘以 2
-
int a = 2; a >> 1; ---> 1 // a/2 a << 1; ---> 4 // a*2
-
-
位操作交换两数
-
位操作交换两数可以不需要第三个临时变量，虽然普通操作也可以做到，但是没有其效率高
//不通过临时变量交换两数 //普通操作 void swap(int &a, int &b) { a = a + b; b = a - b; a = a - b; } //位与操作 void swap(int &a, int &b) { a ^= b; b ^= a; a ^= b; }位与操作解释：
第一步：a ^= b ---> a = (a^b);
第二步：b ^= a ---> b = b(ab) ---> b = (bb)a = a
第三步：a ^= b ---> a = (ab)a = (aa)b = b
-
-
位操作判断奇偶数
-
只要根据数的最后一位是 0 还是 1 来决定即可，为 0 就是偶数，为 1 就是奇数。
if((a & 1)== 0) { //偶数 } if((a & 1)== 1){ //奇数 }
-
-
位操作交换符号
-
交换符号将正数变成负数，负数变成正数
int reversal(int a) { return ~a + 1; } //整数取反加1，正好变成其对应的负数(补码表示)；负数取反加一，则变为其原码，即正数
-
-
位操作求绝对值
- 整数的绝对值是其本身，负数的绝对值正好可以对其进行取反加一求得，即我们首先判断其符号位（整数右移 31 位得到 0，负数右移 31 位得到 -1,即 0xffffffff），然后根据符号进行相应的操作
int abs(int a) { int i = a >> 31; return i == 0 ? a : (~a + 1); }- 上面的操作可以进行优化，可以将
i == 0的条件判断语句去掉。我们都知道符号位i只有两种情况，即 i = 0 为正，i = -1为负。对于任何数与 0 异或都会保持不变，与-1 即 0xffffffff进行异或就相当于对此数进行取反,因此可以将上面三目元算符转换为((a^i)-i)，即整数时 a 与 0 异或得到本身，再减去 0，负数时与0xffffffff 异或将 a 进行取反，然后在加上 1，即减去i(i =-1)
int abs2(int a) { int i = a >> 31; return ((a^i) - i); } -
位操作进行高低位交换
- 给定一个 16 位的无符号整数，将其高 8 位与低 8 位进行交换，求出交换后的值，如：
34520的二进制表示： 10000110 11011000 将其高8位与低8位进行交换，得到一个新的二进制数： 11011000 10000110 其十进制为55430从上面移位操作我们可以知道，只要将无符号数 a>>8 即可得到其高 8 位移到低 8 位，高位补 0；将 a<<8 即可将 低 8 位移到高 8 位，低 8 位补 0，然后将 a>>8 和 a<<8 进行或操作既可求得交换后的结果。
unsigned short a = 34520; a = (a >> 8) | (a << 8); -
位操作进行二进制逆序
-
- 将无符号数的二进制表示进行逆序，求取逆序后的结果，如
数34520的二进制表示： 10000110 11011000 逆序后则为： 00011011 01100001 它的十进制为7009在字符串逆序过程中，可以从字符串的首尾开始，依次交换两端的数据。在二进制中使用位的高低位交换会更方便进行处理，这里我们分组进行多步处理。
-
第一步:以每 2 位为一组，组内进行高低位交换
交换前： 10 00 01 10 11 01 10 00 交换后： 01 00 10 01 11 10 01 00
-
-
第二步：在上面的基础上，以每 4 位为 1 组，组内高低位进行交换
交换前： 0100 1001 1110 0100 交换后： 0001 0110 1011 0001
-
-
-
第三步：以每 8 位为一组，组内高低位进行交换
交换前： 00010110 10110001 交换后： 01100001 00011011 -
第四步：以每16位为一组，组内高低位进行交换
交换前： 0110000100011011 交换后： 0001101101100001对于上面的第一步，依次以 2 位作为一组，再进行组内高低位交换，这样处理起来比较繁琐，下面介绍另外一种方法进行处理。先分别取原数 10000110 11011000 的奇数位和偶数位，将空余位用 0 填充：
原数： 10000110 11011000 奇数位： 10000010 10001000 偶数位： 00000100 01010000再将奇数位右移一位，偶数位左移一位，此时将两个数据相或即可以达到奇偶位上数据交换的效果：
原数： 10000110 11011000 奇数位右移一位： 0 10000010 1000100 偶数位左移一位：0000100 01010000 0 两数相或得到： 01001001 11100100上面的方法用位操作可以表示为：
取a的奇数位并用 0 进行填充可以表示为：a & 0xAAAA
取a的偶数为并用 0 进行填充可以表示为：a & 0x5555 因此，上面的第一步可以表示为：
a = ((a & 0xAAAA) >> 1) | ((a & 0x5555) << 1)
同理，可以得到其第二、三和四步为：
a = ((a & 0xCCCC) >> 2) | ((a & 0x3333) << 2)
a = ((a & 0xF0F0) >> 4) | ((a & 0x0F0F) << 4)
a = ((a & 0xFF00) >> 8) | ((a & 0x00FF) << 8)
因此整个操作为：unsigned short a = 34520; a = ((a & 0xAAAA) >> 1) | ((a & 0x5555) << 1); a = ((a & 0xCCCC) >> 2) | ((a & 0x3333) << 2); a = ((a & 0xF0F0) >> 4) | ((a & 0x0F0F) << 4); a = ((a & 0xFF00) >> 8) | ((a & 0x00FF) << 8);
-
- 位操作统计二进制中 1 的个数
统计二进制1的个数可以分别获取每个二进制位数，然后再统计其1的个数，此方法效率比较低。这里介绍另外一种高效的方法，同样以 34520 为例，我们计算其 a &= (a-1)的结果：
- 第一次：计算前：1000 0110 1101 1000 计算后：1000 0110 1101 0000
- 第二次：计算前：1000 0110 1101 0000 计算后：1000 0110 1100 0000
- 第二次：计算前：1000 0110 1100 0000 计算后：1000 0110 1000 0000 我们发现，没计算一次二进制中就少了一个 1，则我们可以通过下面方法去统计：
count = 0
while(a){
a = a & (a - 1);
count++;
}
找出没有重复的数
给你一组整型数据，这些数据中，其中有一个数只出现了一次，其他的数都出现了两次，让你来找出一个数 。
这道题可能很多人会用一个哈希表来存储，每次存储的时候，记录 某个数出现的次数，最后再遍历哈希表，看看哪个数只出现了一次。这种方法的时间复杂度为 O(n)，空间复杂度也为 O(n)了。
然而我想告诉你的是，采用位运算来做，绝对高逼格！
我们刚才说过，两个相同的数异或的结果是 0，一个数和 0 异或的结果是它本身，所以我们把这一组整型全部异或一下，例如这组数据是：1， 2， 3， 4， 5， 1， 2， 3， 4。其中 5 只出现了一次，其他都出现了两次，把他们全部异或一下，结果如下：
由于异或支持交换律和结合律，所以:
1^ 2^ 3^ 4^ 5^ 1^ 2^ 3^4 = （1^ 1)^(2 ^ 2)^ (3^ 3)^ (4^ 4)^5= 00005 = 5。
也就是说，那些出现了两次的数异或之后会变成0，那个出现一次的数，和 0 异或之后就等于它本身。就问这个解法牛不牛逼？所以代码如下
m的n次方
如果让你求解 m 的 n 次方，并且不能使用系统自带的 pow 函数，你会怎么做呢？这还不简单，连续让 n 个 m 相乘就行了，代码如下：
int pow(int n){
int tmp = 1;
for(int i = 1; i <= n; i++) {
tmp = tmp * m;
}
return tmp;
}
不过你要是这样做的话，我只能呵呵，时间复杂度为 O(n) 了，怕是小学生都会！如果让你用位运算来做，你会怎么做呢？
我举个例子吧，例如 n = 13，则 n 的二进制表示为 1101, 那么 m 的 13 次方可以拆解为:
\(m^{1101} = m^{0001} * m^{0100} * m^{1000}\)。
我们可以通过 & 1和 >>1 来逐位读取 1101，为1时将该位代表的乘数累乘到最终结果。直接看代码吧，反而容易理解：
int pow(int n){
int sum = 1;
int tmp = m;
while(n != 0){
if(n & 1 == 1){
sum *= tmp;
}
tmp *= tmp;
n = n >> 1;
}
return sum;
}
时间复杂度近为 \(O(logn)\)，而且看起来很牛逼。
这里说一下，位运算很多情况下都是很二进制扯上关系的，所以我们要判断是否是否位运算，很多情况下都会把他们拆分成二进制，然后观察特性，或者就是利用与，或，异或的特性来观察，总之，我觉得多看一些例子，加上自己多动手，就比较容易上手了。所以呢，继续往下看，注意，先别看答案，先看看自己会不会做。
找出不大于N的最大的2的幂指数
传统的做法就是让 1 不断着乘以 2，代码如下：
int findN(int N){
int sum = 1;
while(true){
if(sum * 2 > N){
return sum;
}
sum = sum * 2;
}
}
这样做的话，时间复杂度是 $O(logn)￥，那如果改成位运算，该怎么做呢？我刚才说了，如果要弄成位运算的方式，很多时候我们把某个数拆成二进制，然后看看有哪些发现。这里我举个例子吧。
例如 N = 19，那么转换成二进制就是 00010011（这里为了方便，我采用8位的二进制来表示）。那么我们要找的数就是，把二进制中最左边的 1 保留，后面的 1 全部变为 0。即我们的目标数是 00010000。那么如何获得这个数呢？相应解法如下：
1、找到最左边的 1，然后把它右边的所有 0 变成 1
2、把得到的数值加 1，可以得到 00100000即 00011111 + 1 = 00100000。
3、把 得到的 00100000 向右移动一位，即可得到 00010000，即 00100000 >> 1 = 00010000。
那么问题来了，第一步中把最左边 1 中后面的 0 转化为 1 该怎么弄呢？我先给出代码再解释吧。下面这段代码就可以把最左边 1 中后面的 0 全部转化为 1，
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
就是通过把 n 右移并且做或运算即可得到。我解释下吧，我们假设最左边的 1 处于二进制位中的第 k 位(从左往右数),那么把 n 右移一位之后，那么得到的结果中第 k+1 位也必定为 1,然后把 n 与右移后的结果做或运算，那么得到的结果中第 k 和 第 k + 1 位必定是 1;同样的道理，再次把 n 右移两位，那么得到的结果中第 k+2和第 k+3 位必定是 1,然后再次做或运算，那么就能得到第 k, k+1, k+2, k+3 都是 1，如此往复下去….
最终的代码如下
int findN(int n){
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8 // 整型一般是 32 位，上面我是假设 8 位。
return (n + 1) >> 1;
}
这种做法的时间复杂度近似 O(1)，重点是，高逼格。
不过呢，我给出的这些例子中，并不是让你们学会了这些题就 Ok，而且让你们有一个意识：很多时候，位运算是个不错的选择，至少时间效率会快很多，而且高逼格，装逼必备。所以呢，以后可以多尝试去使用位运算哦
