[转]位运算（简版：方便+好用+好看+无废话）-白红宇

[转]位运算（简版：方便+好用+好看+无废话）

阅读量：5142 次

发布时间：2019-06-13

本文共 6621 字，大约阅读时间需要 22 分钟。

By：Hellis

我是在Nettle和matrix67两位大牛的基础上修改的。把过多的废话和例题给和谐了，剩下的都是重点和基础。

至于为什么文中用了N多个“1314520”这就不能问我了，我是无辜的……55555。

Pascal和C中的位运算符号

下面的a和b都是整数类型，则：

C语言 | Pascal语言

-------+-------------

a & b | a and b

a | b | a or b

a ^ b | a xor b

~a | not a

a << b | a shl b

a >> b | a shr b

注意C中的逻辑运算和位运算符号是不同的。520|1314=1834，但520||1314=1，因为逻辑运算时520和1314都相当于True。同样的，!a和~a也是有区别的。

各种位运算的使用

=== 1. & 运算 ===

二进制中 1 & 1 = 1 1 & 0 = 0 0 & 0 = 0 0 & 1 = 0

& 运算通常用于二进制取位操作，例如一个数 & 1的结果就是取二进制的最末位。这可以用来判断一个整数的奇偶，二进制的最末位为0表示该数为偶数，最末位为1表示该数为奇数.

=== 2. | 运算 ===

| 运算通常用于二进制特定位上的无条件赋值，例如一个数 | 1的结果就是把二进制最末位强行变成1。如果需要把二进制最末位变成0，对这个数 | 1之后再减一就可以了，其实际意义就是把这个数强行变成最接近的偶数。

=== 3. ^ 运算 ===

^ 运算通常用于对二进制的特定一位进行取反操作，因为异或可以这样定义：0和1异或0都不变，异或1则取反。

^ 运算的逆运算是它本身，也就是说两次异或同一个数最后结果不变，即(a ^ b) ^ b = a。^ 运算可以用于简单的加密，比如我想对我MM说1314520，但怕别人知道，于是双方约定拿我的生日19880516作为密钥。1314520 ^ 19880516 = 20665500，我就把20665500告诉MM。MM再次计算20665500 ^ 19880516的值，得到1314520，于是她就明白了我的企图。

=== 4. ~ 运算 ===

~ 运算的定义是把内存中的0和1全部取反。使用 ~ 运算时要格外小心，你需要注意整数类型有没有符号。如果 ~ 的对象是无符号整数（不能表示负数），那么得到的值就是它与该类型上界的差，因为无符号类型的数是用$0000到$FFFF依次表示的。下面的两个程序（仅语言不同）均返回65435。

=== 5. << 运算 ===

a << b就表示把a转为二进制后左移b位（在后面添b个0）。例如100的二进制为1100100，而110010000转成十进制是400，那么100 << 2 = 400。可以看出，a << b的值实际上就是a乘以2的b次方，因为在二进制数后添一个0就相当于该数乘以2。

通常认为a << 1比a * 2更快，因为前者是更底层一些的操作。因此程序中乘以2的操作请尽量用左移一位来代替。

=== 6. >> 运算 ===

和 >> 相似，a >> b表示二进制右移b位（去掉末b位），相当于a除以2的b次方（取整）。我们也经常用 >> 1来代替 / 2(div 2)，比如二分查找、堆的插入操作等等。想办法用 >> 代替除法运算可以使程序效率大大提高。最大公约数的二进制算法用除以2操作来代替慢得出奇的 % (mod)运算，效率可以提高60%。

位运算的简单应用

有时我们的程序需要一个规模不大的Hash表来记录状态。比如，做数独时我们需要27个Hash表来统计每一行、每一列和每一个小九宫格里已经有哪些数了。此时，我们可以用27个小于2^9的整数进行记录。例如，一个只填了2和5的小九宫格就用数字18表示（二进制为000010010），而某一行的状态为511则表示这一行已经填满。需要改变状态时我们不需要把这个数转成二进制修改后再转回去，而是直接进行位操作。在搜索时，把状态表示成整数可以更好地进行判重等操作。这道题是在搜索中使用位运算加速的经典例子。以后我们会看到更多的例子。

下面列举了一些常见的二进制位的变换操作。

功能 | 示例 | 位运算

----------------------+---------------------------+--------------------

去掉最后一位 | (101101->10110) | x >> 1

在最后加一个0 | (101101->1011010) | x << 1

在最后加一个1 | (101101->1011011) | (x << 1) + 1

把最后一位变成1 | (101100->101101) | x | 1

把最后一位变成0 | (101101->101100) | (x | 1) - 1

最后一位取反 | (101101->101100) | x ^ 1

把右数第k位变成1 | (101001->101101,k=3) | x | (1 << (k-1))

把右数第k位变成0 | (101101->101001,k=3) | x & ~(1 << (k-1))

右数第k位取反 | (101001->101101,k=3) | x ^ (1 << (k-1))

取末三位 | (1101101->101) | x & 7

取末k位 | (1101101->1101,k=5) | x & (1 << k-1)

取右数第k位 | (1101101->1,k=4) | x >> (k-1) & 1

把末k位变成1 | (101001->101111,k=4) | x | (1 << k-1)

末k位取反 | (101001->100110,k=4) | x ^ (1 << k-1)

把右边连续的1变成0 | (100101111->100100000) | x & (x+1)

把右起第一个0变成1 | (100101111->100111111) | x | (x+1)

把右边连续的0变成1 | (11011000->11011111) | x | (x-1)

取右边连续的1 | (100101111->1111) | (x ^ (x+1)) >> 1

去掉右起第一个1的左边 | (100101000->1000) | x & (x ^ (x-1))

最后这一个在树状数组中会用到。

整数类型的储存

我们前面所说的位运算都没有涉及负数，都假设这些运算是在unsigned/word类型（只能表示正数的整型）上进行操作。但计算机如何处理有正负符号的整数类型呢？

由此你可以清楚地看到计算机是如何储存一个整数的：计算机用Ox0000到Ox7FFF依次表示0到32767的数，剩下的Ox8000到OxFFFF依次表示-32768到-1的数。32位有符号整数的储存方式也是类似的。稍加注意你会发现，二进制的第一位是用来表示正负号的，0表示正，1表示负。这里有一个问题：0本来既不是正数，也不是负数，但它占用了Ox0000的位置，因此有符号的整数类型范围中正数个数比负数少一个。对一个有符号的数进行 ~ 运算后，最高位的变化将导致正负颠倒，并且数的绝对值会差1。也就是说，~ a实际上等于-a-1。这种整数储存方式叫做“补码”。

二进制中的1有奇数个还是偶数个

我们可以用下面的代码来计算一个32位整数的二进制中1的个数的奇偶性，当输入数据的二进制表示里有偶数个数字1时程序输出0，有奇数个则输出1。例如，1314520的二进制101000000111011011000中有9个1，则x=1314520时程序输出1。

同样是判断二进制中1的个数的奇偶性，下面这段代码就强了。你能看出这个代码的原理吗？

int main()

{

long int x;

scanf("%d",&x);

x = x ^ (x >> 1);

x = x ^ (x >> 2);

x = x ^ (x >> 4);

x = x ^ (x >> 8);

x = x ^ (x >> 16);

printf("%d\n",x & 1);

return 0;

}

为了说明上面这段代码的原理，我们还是拿1314520出来说事。1314520的二进制为101000000111011011000，一次运算得到的结果是一个新的二进制数，其中右起第i位上的数表示原数中第i和i+1位上有奇数个1还是偶数个1。比如，最右边那个0表示原数末两位有偶数个1，右起第3位上的1就表示原数的这个位置和前一个位置中有奇数个1。

结果里的每个1表示原数的该位置及其前面三个位置中共有奇数个1，每个0就表示原数对应的四个位置上共偶数个1。一直做到第五次异或结束后，得到的二进制数的最末位就表示整个32位数里有多少个1，这就是我们最终想要的答案。

计算二进制中的1的个数

同样假设x是一个32位整数。经过下面五次赋值后，x的值就是原数的二进制表示中数字1的个数。比如，初始时x为1314520（网友抓狂：能不能换一个数啊），那么最后x就变成了9，它表示1314520的二进制中有9个1。

x = (x & 0x55555555) + ((x >> 1) & 0x55555555);

x = (x & 0x33333333) + ((x >> 2) & 0x33333333);

x = (x & 0x0F0F0F0F) + ((x >> 4) & 0x0F0F0F0F);

x = (x & 0x00FF00FF) + ((x >> 8) & 0x00FF00FF);

x = (x & 0x0000FFFF) + ((x >> 16) & 0x0000FFFF);

为了便于解说，我们下面仅说明这个程序是如何对一个8位整数进行处理的。我们拿数字211（我们班某MM的生日）来开刀。211的二进制为11010011。

+---+---+---+---+---+---+---+---+

| 1 | 1 | 0 | 1 | 0 | 0 | 1 | 1 | <---原数

+---+---+---+---+---+---+---+---+

| 1 0 | 0 1 | 0 0 | 1 0 | <---第一次运算后

+-------+-------+-------+-------+

| 0 0 1 1 | 0 0 1 0 | <---第二次运算后

+---------------+---------------+

| 0 0 0 0 0 1 0 1 | <---第三次运算后，得数为5

+-------------------------------+

整个程序是一个分治的思想。第一次我们把每相邻的两位加起来，得到每两位里1的个数，比如前两位10就表示原数的前两位有2个1。第二次我们继续两两相加，10+01=11，00+10=10，得到的结果是00110010，它表示原数前4位有3个1，末4位有2个1。最后一次我们把0011和0010加起来，得到的就是整个二进制中1的个数。程序中巧妙地使用取位和右移，比如第二行中0x33333333的二进制为00110011001100….，用它和x做 & 运算就相当于以2为单位间隔取数。>> 的作用就是让加法运算的相同数位对齐。

二分查找32位整数的前导0个数

int nlz(unsigned x)

{

int n;

if (x == 0) return(32);

n = 1;

if ((x >> 16) == 0) {n = n +16; x = x <<16;}

if ((x >> 24) == 0) {n = n + 8; x = x << 8;}

if ((x >> 28) == 0) {n = n + 4; x = x << 4;}

if ((x >> 30) == 0) {n = n + 2; x = x << 2;}

n = n - (x >> 31);

return n;

}

只用位运算来取绝对值

假设

x为32位整数，则x ^ ( ~ (x >> 31) + 1) + x >> 31的结果是x的绝对值

x >> 31是二进制的最高位，它用来表示x的符号。如果它为0（x为正），则 ~ (x >> 31) + 1等于0x00000000，异或任何数结果都不变；如果最高位为1（x为负），则 ~ (x >> 31) + 1等于0xFFFFFFFF，x异或它相当于所有数位取反，异或完后再加一。

高低位交换

例如，数1314520用二进制表示为0000 0000 0001 0100 0000 1110 1101 1000（添加了11个前导0补足为32位），其中前16位为高位，即0000 0000 0001 0100；后16位为低位，即0000 1110 1101 1000。将它的高低位进行交换，我们得到了一个新的二进制数0000 1110 1101 1000 0000 0000 0001 0100。它即是十进制的249036820。

当时几乎没有人想到用一句位操作来代替冗长的程序。使用位运算的话两句话就完了。

#include <iostream>

using namespace std;

int main()

{

long int x;

scanf("%d",&x);

x= ((x >> 16) | (x << 16));

printf("%d\n",x);

return 0;

}

而事实上，Pascal有一个系统函数swap直接就可以用。