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

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直接就可以用。
二进制逆序
    下面的程序读入一个32位整数并输出它的二进制倒序后所表示的数。
    输入： 1314520    （二进制为00000000000101000000111011011000）
    输出： 460335104  （二进制为00011011011100000010100000000000）
#include <iostream>

using namespace std;

int main()

{

long int x;

  scanf("%d",&x);

  x = (x & 0x55555555) <<  1 | (x & 0xAAAAAAAA) >>  1;

  x = (x & 0x33333333) <<  2 | (x & 0xCCCCCCCC) >>  2;

  x = (x & 0x0F0F0F0F) <<  4 | (x & 0xF0F0F0F0) >>  4;

  x = (x & 0x00FF00FF) <<  8 | (x & 0xFF00FF00) >>  8;

  x = (x & 0x0000FFFF) << 16 | (x & 0xFFFF0000) >> 16;

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

  return 0;

}
    它的原理和刚才求二进制中1的个数那个例题是大致相同的。程序首先交换每相邻两位上的数，以后把互相交换过的数看成一个整体，继续进行以2位为单位、以4位为单位的左右对换操作。我们再次用8位整数211来演示程序执行过程：
+---+---+---+---+---+---+---+---+
| 1 | 1 | 0 | 1 | 0 | 0 | 1 | 1 |   <---原数
+---+---+---+---+---+---+---+---+
|  1 1  |  1 0  |  0 0  |  1 1  |   <---第一次运算后
+-------+-------+-------+-------+
|    1 0 1 1    |    1 1 0 0    |   <---第二次运算后
+---------------+---------------+
|        1 1 0 0 1 0 1 1        |   <---第三次运算后
+-------------------------------+