位运算

位运算的技巧总结。

位操作基本概念

基本概念如上图。

这里重点说明一下，不论左移还是右移，都是右操作数表示移动的位数。操作的都是补码！！！

计算机中对数字的表示有三种方式：原码，反码，补码：

• 原码表示法在数值前面增加了一位符号位（即最高位为符号位）：正数该位为0，负数该位为1。比如十进制3如果用8个二进制位来表示就是 00000011， -3就是 10000011。
• 反码表示方法：正数的反码是其本身；负数的反码是在其原码的基础上，符号位不变，其余各个位取反。
• 补码表示方法：正数的补码是其本身；负数的补码是在其原码的基础上，符号位不变，其余各位取反，最后+1。 (即在反码的基础上+1)。或者在原码的基础上，从最低位到最高位找起，找到第一个1不变，以后各位1变0、0变1，符号位变不变取决于原码是表示负数本身还是负数绝对值（补码的符号位是1表示是负数，符号位是0表示是正数）。
• 移码表示方法：就是补码的符号位取反。目的是把有符号数变成无符号数好比较。

位操作的奇淫技巧(⊙﹏⊙)

断奇偶

判断奇数还是偶数就看最后一位是0还是1就好了，所以有以下技巧：

# 2.7for i in range(100):    if i&1:        print i

这会打印所有奇数，显然偶数也可以这样找出来。

交换值

a^=bb^=aa^=b/*分析如下：a^=b意为a=a^bb^=a意为b=b^a=b^(a^b)=a  异或满足交换律和结合律a^=b意为a=a^b=(a^b)^b=a^b^a=b 注意这里第一个b不同于第二个b，第二个b由第二步知已经变成a了*/

这里交换了a，b的值不用第三个变量（python里不用这个也可以原地交换O(∩_∩)O哈！）

变换符号

实际上就是求补运算，对一个正数求补就变成了负数，对一个负数求补就变成了正数（牢记计算机内部都是补码表示）。

求补过程：包括符号位在内，将操作数各位取反再在最低位+1。

#2.7a=-5print ~a+1

求绝对值

同理利用上述说到的求补运算。

先看下面的例子：

#2.7a=-5print a>>31#结果是-1

所以这里Python似乎是算术右移。

这里可以更加简洁一些：

对于任何数，与0异或都会保持不变，与-1即0xFFFFFFFF异或就相当于取反（各位取反的意思）。因此，a与i异或后再减i（因为i为0或-1，所以减i即是要么加0要么加1）也可以得到绝对值。

#2.7a=-5i=a>>31print (i^a)-i

这里就两个情况：i=0，则 0^a=a,结果是a本身的值；i=-1，则-1^a等于a的各位取反，-i相当于加1，则这个过程完成了求补。

二进制高低位交换

给出一个16位的无符号整数。称这个二进制数的前8位为“高位”，后8位为“低位”。现在写一程序将它的高低位交换。例如，数34520用二进制表示为：

10000110 11011000

将它的高低位进行交换，我们得到了一个新的二进制数：

​ 11011000 10000110

它即是十进制的55430。

这个问题用位操作解决起来非常方便，设x=34520=10000110 11011000(二进制) 由于x为无符号数，右移时会执行逻辑右移即高位补0，因此x右移8位将得到0000000010000110。而x左移8位将得到11011000 00000000。可以发现只要将x>>8与x<<8这两个数相或就可以得到11011000 10000110

public class test1{    public static void main(String args[])    {        int a=3344520;        System.out.println(Integer.toBinaryString(a));        a=(a>>16)|(a<<16);        System.out.println(Integer.toBinaryString(a));    }}/*输出结果如下：（可能前面的0会不输出，自己补全即可）0000  0000 0011 0011   0000 1000 1000 10000000  1000 1000 1000   0000 0000 0011 0011*/

注意，上面引用的讲解是16位无符号数，java中int是32位 ，所以移动了16位。

二进制逆序

可以通过如下步骤完成 16进制的逆序：

/*第一步：每2位为一组，组内高低位交换      10 00 01 10  11 01 10 00  -- >01 00 10 01 11 10 01 00第二步：每4位为一组，组内高低位交换      0100 1001 1110 0100  -->0001 0110 1011 0001第三步：每8位为一组，组内高低位交换      00010110 10110001  -->01100001 00011011第四步：每16位为一组，组内高低位交换      01100001 00011011  -->00011011 01100001对第一步，可以依次取出每2位作一组，再组内高低位交换，这样有点麻烦，下面介绍一种非常有技巧的方法。先分别取10000110 11011000的奇数位和偶数位，空位以下划线表示。      原 数    10000110 11011000      奇数位   1_0_0_1_ 1_0_1_0_      偶数位   _0_0_1_0 _1_1_0_0将下划线用0填充，可得      原 数    10000110 11011000      奇数位   10000010 10001000      偶数位   00000100 01010000再将奇数位右移一位，偶数位左移一位，此时将这两个数据相或即可以达到奇偶位上数据交换的效果了。（很好理解，错开相加嘛）      原 数     10000110 11011000      奇数位右移 01000001 01000100        偶数位左移 00001000 10100000      相或得到   01001001 11100100可以看出，结果完全达到了奇偶位的数据交换，再来考虑代码的实现——      取x的奇数位并将偶数位用0填充用代码实现就是x & 0xAAAA      取x的偶数位并将奇数位用0填充用代码实现就是x & 0x5555因此，第一步就用代码实现就是：       x = ((x & 0xAAAA) >> 1) | ((x & 0x5555) << 1);*/

上述讲解中，用了16位的，这里还是改成32位。

        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);/*16位*/

a = ((a & 0xCCCCCCCC) >> 2) | ((a & 0x33333333) << 2);a = ((a & 0xF0F0F0F0) >> 4) | ((a & 0x0F0F0F0F) << 4);a = ((a & 0xFF00FF00) >> 8) | ((a & 0x00FF00FF) << 8);a=  ((a&0xFFFF0000)>>16)|((a&0x0000FFFF)<<16);/*32位*//*上述结果如下：1000 0110 1101 10000001 1011 0110 00010000 0000 0000 0000 1000 0110 1101 10000001 1011 0110 0001 0000 0000 0000 0000还是0自己补齐吧。*/

很遗憾，这里发现了一个坑

#include <stdio.h>template <class T>void PrintfBinary(T a){    int i;    for (i = sizeof(a) * 8 - 1; i >= 0; --i)    {        if ((a >> i) & 1)            putchar('1');        else            putchar('0');        if (i == 16)            putchar(' ');    }    putchar('\n');}int main(){    int a = 3344520;    PrintfBinary(a);    a=((a&0xAAAAAAAA)>>1)|((a&0x55555555)<<1);    a = ((a & 0xCCCCCCCC) >> 2) | ((a & 0x33333333) << 2);    a = ((a & 0xF0F0F0F0) >> 4) | ((a & 0x0F0F0F0F) << 4);    a = ((a & 0xFF00FF00) >> 8) | ((a & 0x00FF00FF) << 8);    a=  ((a&0xFFFF0000)>>16)|((a&0x0000FFFF)<<16);    PrintfBinary(a);}

当这里用3344520时，c++运行正确而java错误了。。

java:

0000 0000 0011 0011 0000 1000 1000 1000
1111 1111 1111 1111 1100 1100 0000 0000

c++:

0000 0000 0011 0011 0000 1000 1000 1000
0001 0001 0001 0000 1100 1100 0000 0000

这个坑待填。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

统计二进制中1的个数

最快的方法，虽然看着就蛋疼。

#include <stdio.h>template <class T>void PrintfBinary(T a){    int i;    for (i = sizeof(a) * 8 - 1; i >= 0; --i)    {        if ((a >> i) & 1)            putchar('1');        else            putchar('0');        if (i == 16)            putchar(' ');    }    putchar('\n');}int main(){    int a = 55;    PrintfBinary(a);    a=((a&0xAAAAAAAA)>>1)+(a&0x55555555);    PrintfBinary(a);    a = ((a & 0xCCCCCCCC) >> 2) + (a & 0x33333333);    PrintfBinary(a);    a = ((a & 0xF0F0F0F0) >> 4) + (a & 0x0F0F0F0F);    PrintfBinary(a);    a = ((a & 0xFF00FF00) >> 8) + (a & 0x00FF00FF);    PrintfBinary(a);    a=  ((a&0xFFFF0000)>>16)+(a&0x0000FFFF);    PrintfBinary(a);    printf("%d",a);}

和二进制逆序相似。

第一步：每2位为一组，组内高低位相加

​ 10 00 01 10 11 01 10 00

–>01 00 01 01 10 01 01 00

第二步：每4位为一组，组内高低位相加(这里高低位是一组内，前两个加后两个)

​ 0100 0101 1001 0100

–>0001 0010 0011 0001

第三步：每8位为一组，组内高低位相加

​ 00010010 00110001

–>00000011 00000100

第四步：每16位为一组，组内高低位相加

​ 00000011 00000100

–>00000000 00000111

这样最后得到的00000000 00000111即7即34520二进制中1的个数。类似上文中对二进制逆序的做法不难实现第一步的代码：

​ x = ((x & 0xAAAA) >> 1) + (x & 0x5555);

我的解法：

class Solution:    def NumberOf1(self, n):        if n<0:            return 32-bin(-n-1).count('1')        else:            return bin(n).count('1')

我这里用了python的库，bin函数转二进制，但是转换的结果是原码的形式，符号仍然保留。正数时候很好处理，关键在于负数。负数求补是正数，求补的过程是先求反码（各位取反）再加1。我这里逆序操作，先把正数-1，这时候再取反就是原来负数的补码表示，一共32位，so~~~

别人的解法：

public class Solution {       public int NumberOf1(int n) {           int count = 0;           while(n!= 0){               count++;               n = n & (n - 1);           }           return count;       }   }

如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减1，那么原来处在整数最右边的1就会变为0，原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。

​ 举个例子一个二进制数1100，从右边数起第三位是处于最右边的一个1。减去1后，第三位变成0，它后面的两位0变成了1，而前面的1保持不变，因此得到的结果是1011.我们发现减1的结果是把最右边的一个1开始的所有位都取反了。这个时候如果我们再把原来的整数和减去1之后的结果做与运算，从原来整数最右边一个1那一位开始所有位都会变成0。如1100&1011=1000.也就是说，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0.那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。

找出只出现一次的数字

利用异或运算的两个特性：

1. 自己与自己异或结果为0
2. 异或满足交换律。

#include <stdio.h>int main(){    const int MAXN = 15;    int a[MAXN] = {1, 347, 6, 9, 13, 65, 889, 712, 889, 347, 1, 9, 65, 13, 712};    int lostNum = 0;    for (int i = 0; i < MAXN; i++)        lostNum ^= a[i];    printf("缺失的数字为:  %d\n", lostNum);    return 0;}

快速找到只出现一次的数字。

如果找到两个出现一次的数字呢？

L=[1, 2, 3, 4, 1,  2, 3, 4, 0, 5]def search(L):    tmp=0    for x in L:        tmp^=x    index=0    a=b=0    for i in range(32):        if ((tmp>>i)&1)==1:            index=i    for x in L:        if ((x>>index)&1)==1:            a^=x        else:            b^=x    return (a,b)print search(L)

设题目中这两个只出现1次的数字分别为A和B，如果能将A，B分开到二个数组中，那显然符合“异或”解法的关键点了。因此这个题目的关键点就是将A，B分开到二个数组中。由于A，B肯定是不相等的，因此在二进制上必定有一位是不同的。根据这一位是0还是1可以将A，B分开到A组和B组。而这个数组中其它数字要么就属于A组，要么就属于B组。再对A组和B组分别执行“异或”解法就可以得到A，B了。而要判断A，B在哪一位上不相同，只要根据A异或B的结果就可以知道了，这个结果在二进制上为1的位都说明A，B在这一位上是不相同的。

所以，程序中先把所有元素异或，结果中为1的位就是A、B中不相同的位，从最低位开始找到一个，用它分组，A，B必在两个组中。

两个数相加

public class Solution {    public int Add(int num1,int num2)     {        if(num2==0)            return num1;        if(num1==0)            return num2;        int sum=0;        while (num2!=0)//知道进位部分为0        {            sum=num1^num2;//先求不带进位的加法            num2=(num1&num2)<<1;//只求进位部分            num1=sum;         }        return sum;    }

这道题用python代码会报错，求-1+2的时候，留坑。。。