C/C++位操作技巧

检测一个无符号数是不为2^n-1(^为幂)： x&(x+1)

将最右侧0位改为1位： x | (x+1)

 

使用位运算的无分支代码：

计算绝对值 

int abs( int x )

{

 int y ;

 y = x >> 31 ;

return (x^y)-y ; //or: (x+y)^y 

}

符号函数：sign(x) = -1, x<0; 0, x == 0 ; 1, x > 0

int sign(int x)

{ return (x>>31) | (unsigned(-x))>>31 ;  //x=-2^31时失败(^为幂)

}

不使用第三方交换x,y:

1.x ^= y ; y ^= x ; x ^= y ;

2.x = x+y ; y = x-y ; x = x-y ;

3.x = x-y ; y = y+x ; x = y-x ;

4.x = y-x ; x = y-x ; x = x+y ;

位计数,统计1位的数量：

1.

int pop(unsigned x)

{

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

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

x = x + (x>>8) ;

x = x + (x>>16) ;

return x & 0x0000003f ;

}

 2.

int pop(unsigned x)

{

static char table[256] = { 0,1,1,2, 1,2,2,3, ...., 6,7,7,8 } ;

return table[x&0xff]+table[(x>>8)&0xff]+table[(x>>16)&0xff]+table[(x>>24)] ;

}

 

奇偶性计算:

x = x ^ ( x>>1 ) ;

x = x ^ ( x>>2 ) ;

x = x ^ ( x>>4 ) ;

x = x ^ ( x>>8 ) ;

x = x ^ ( x>>16 ) ;

结果中位于x最低位，对无符号x,结果的第i位是原数第i位到最左侧位的奇偶性

 

位反转：

unsigned rev(unsigned x)

{

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

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

x = (x & 0x0f0f0f0f) << 4 | (x>>4) & 0x0f0f0f0f ;

x = (x<<24) | ((x&0xff00)<<8) | ((x>>8) & 0xff00) | (x>>24) ;

return x ;

}

 

按位与（Bitwise AND），运算符号为&

a&b 的操作的结果：a、b中对应位同时为1，则对应结果位也为1、

例如：

10010001101000101011001111000

&             111111100000000   

---------------------------------------------

                                   10101100000000

对10101100000000进行右移8位得到的是101011，这就得到了a的8~15位的掩码了。那么根据这个启示，判断一个整数是否是处于 0-65535 之间（常用的越界判断）：

用一般的 (a >= 0) && (a <= 65535) 可能要两次判断。

改用位运算只要一次：

a & ~((1 << 16)-1)

后面的常数是编译时就算好了的。其实只要算一次逻辑与就行了。

 

              

常用技巧： 

 

1、  用于整数的奇偶性判断 

 

一个整数a, a & 1 这个表达式可以用来判断a的奇偶性。二进制的末位为0表示偶数，最末位为1表示奇数。使用a%2来判断奇偶性和a & 1是一样的作用，但是a & 1要快好多。

 

2、  判断n是否是2的正整数冪 

 

(!(n&(n-1)) ) && n

 

举个例子：                                                 

如果n = 16 = 10000， n-1 = 1111

那么：

10000

& 1111

----------

                          0

再举一个例子：如果n = 256 = 100000000， n-1 = 11111111

那么：

100000000

&11111111

--------------

        0

好！看完上面的两个小例子，相信大家都有一个感性的认识。从理论上讲，如果一个数a他是2的正整数幂，那么a 的二进制形式必定为1000…..（后面有0个或者多个0），那么结论就很显然了。

 

3、  统计n中1的个数 

 

朴素的统计办法是：先判断n的奇偶性，为奇数时计数器增加1，然后将n右移一位，重复上面步骤，直到移位完毕。

朴素的统计办法是比较简单的，那么我们来看看比较高级的办法。

 

举例说明，考虑2位整数 n=11，里边有2个1，先提取里边的偶数位10，奇数位01，把偶数位右移1位，然后与奇数位相加，因为每对奇偶位相加的和不会超过“两位”，所以结果中每两位保存着数n中1的个数；相应的如果n是四位整数 n=0111，先以“一位”为单位做奇偶位提取，然后偶数位移位（右移1位），相加；再以“两位”为单位做奇偶提取，偶数位移位（这时就需要移2位），相加，因为此时没对奇偶位的和不会超过“四位”，所以结果中保存着n中1的个数，依次类推可以得出更多位n的算法。整个思想类似分治法。
在这里就顺便说一下常用的二进制数： 

0xAAAAAAAA=10101010101010101010101010101010 

0x55555555 = 1010101010101010101010101010101（奇数位为1，以1位为单位提取奇偶位） 

 

0xCCCCCCCC = 11001100110011001100110011001100

0x33333333 =    110011001100110011001100110011（以“2位”为单位提取奇偶位） 

 

0xF0F0F0F0 = 11110000111100001111000011110000 

0x0F0F0F0F =     1111000011110000111100001111（以“8位”为单位提取奇偶位）

 

0xFFFF0000 =11111111111111110000000000000000                

0x0000FFFF =                 1111111111111111（以“16位”为单位提取奇偶位）

 

例如：32位无符号数的1的个数可以这样数：

int  count_one(unsigned  long  n)
{
     // 0xAAAAAAAA，0x55555555分别是以“1位”为单位提取奇偶位
    n  =  ((n  &   0xAAAAAAAA )  >>   1 )  +  (n  &   0x55555555 );

     // 0xCCCCCCCC，0x33333333分别是以“2位”为单位提取奇偶位
    n  =  ((n  &   0xCCCCCCCC )  >>   2 )  +  (n  &   0x33333333 );

     // 0xF0F0F0F0，0x0F0F0F0F分别是以“4位”为单位提取奇偶位
    n  =  ((n  &   0xF0F0F0F0 )  >>   4 )  +  (n  &   0x0F0F0F0F );

     // 0xFF00FF00，0x00FF00FF分别是以“8位”为单位提取奇偶位
    n  =  ((n  &   0xFF00FF00 )  >>   8 )  +  (n  &   0x00FF00FF );

     // 0xFFFF0000，0x0000FFFF分别是以“16位”为单位提取奇偶位
    n  =  ((n  &   0xFFFF0000 )  >>   16 )  +  (n  &   0x0000FFFF );

     return  n;
}

举个例子吧，比如说我的生日是农历2月11，就用211吧，转成二进制：

                     n = 11010011

计算n = ((n & 0xAAAAAAAA) >> 1) + (n & 0x55555555);

得到              n = 10010010

计算n = ((n & 0xCCCCCCCC) >> 2) + (n & 0x33333333);

得到              n = 00110010

计算n = ((n & 0xF0F0F0F0) >> 4) + (n & 0x0F0F0F0F);

得到              n = 00000101 -----------------à无法再分了，那么5就是答案了。

4、对于正整数的模运算（注意，负数不能这么算）

 

先说下比较简单的：

乘除法是很消耗时间的，只要对数左移一位就是乘以2，右移一位就是除以2，传说用位运算效率提高了60%。

乘以2^k 众所周知：n<<k。所以你以后还会傻傻地去敲2566*4的结果10264吗？直接2566<<4就搞定了，又快又准确。

 

除以2^k众所周知：n>>k。

 

那么mod 2^k 呢？（对2的倍数取模）

n & ((1<<k) - 1)

用通俗的言语来描述就是,对2的倍数取模，只要将数与2的倍数-1做按位与运算即可。

好！方便理解就举个例子吧。

思考：如果结果是要求模2^k时，我们真的需要每次都取模吗？

 

在此很容易让人想到快速幂取模法。

快速幂取模算法

经常做题目的时候会遇到要计算 a^b mod c 的情况，这时候，一个不小心就TLE了。那么如何解决这个问题呢？位运算来帮你吧。

 

首先介绍一下秦九韶算法：(数值分析讲得很清楚)

把一个n次多项式f(x) = a[n]x^n+a[n-1]x^(n-1)+......+a[1]x+a[0]改写成如下形式：

　　f(x) = a[n]x^n+a[n-1]x^(n-1))+......+a[1]x+a[0]

　　= (a[n]x^(n-1)+a[n-1]x^(n-2)+......+a[1])x+a[0]

　　= ((a[n]x^(n-2)+a[n-1]x^(n-3)+......+a[2])x+a[1])x+a[0]

　　=. .....

　　= (......((a[n]x+a[n-1])x+a[n-2])x+......+a[1])x+a[0].

　　求多项式的值时，首先计算最内层括号内一次多项式的值，即

　　v[1]=a[n]x+a[n-1]

　　然后由内向外逐层计算一次多项式的值，即

　　v[2]=v[1]x+a[n-2]

　　v[3]=v[2]x+a[n-3]

　　......

　　v[n]=v[n-1]x+a[0]

这样，求n次多项式f(x)的值就转化为求n个一次多项式的值。

 

好！有了前面的基础知识，我们开始解决问题吧

由(a × b) mod c=( (a mod c) × b) mod c.

我们可以将 b先表示成就：

  b = a[t] × 2^t + a[t-1]× 2^(t-1) + …… + a[0] × 2^0.  (a[i]=[0,1]).

这样我们由 a^b  mod  c = (a^(a[t] ×2^t  +  a[t-1] ×2^（t-1）+ …a[0] ×2^0) mod c.

然而我们求  a^( 2^(i+1) ) mod c=( (a^(2^i)) mod c)^2 mod c .求得。

具体实现如下：

使用秦九韶算法思想进行快速幂模算法，简洁漂亮

//  快速计算 (a ^ p) % m 的值
__int64 FastM(__int64 a, __int64 p, __int64 m)
{ 
     if  (p  ==   0 )  return   1 ;
    __int64  r  =  a  %  m;
    __int64  k  =   1 ;
     while  (p  >   1 )
    {
         if  ((p  &   1 ) != 0 )
        {
            k  =  (k  *  r)  %  m; 
}
              r  =  (r  *  r)  %  m;
            p  >>=   1 ;
        }
         return  (r  *  k)  %  m;
}

 5、计算掩码

比如一个截取低6位的掩码：0×3F
用位运算这么表示：(1 << 6) - 1
这样也非常好读取掩码，因为掩码的位数直接体现在表达式里。

按位或运算很简单，只要a和b中相应位出现1，那么a|b的结果相应位也为1。就不多说了。 

6、子集

　　枚举出一个集合的子集。设原集合为mask，则下面的代码就可以列出它的所有子集： 

 

　　for (i = mask ; i ; i = (i - 1) & mask) ; 

　　

按位异或（xor）^ 操作    按位异或运算  俗称：xor运算   1、xor的基本知识   我们来看看xor运算的机理：   1001011001011----àa xor    1011010001110----àb -------------------------       0010001000101---àc   看了上面的式子，体会到异或运算的原理了吧，就是：0和1异或0都不变，异或1则取反。很容易理解，如果b中的某位为1，那么a xor b 的作用是在a相应的位进行取反操作。用通俗易懂的语言来讲就是xor运算通常用于对二进制的特定一位进行取反操作。 我们再看到上面那个计算式子，如果得到的结果c再与b做异或运算即：   0010001000101---àc xor    1011010001110---àb ----------------------------------       1001011001011---àd   注意到了吧，a == d  是成立的！那么我们可以得到一个结论：(a xor b) xor b = a。 同时我们还可以得到一个很诡异的swap操作： a  ^=  b;  b ^= a; a ^= b; 自己拿起笔来模拟一下就很清楚的了。   2、xor和 not （按位否～）操作之间的关系   事实上很简单，not操作是xor操作的一个特例。取反实质上就是同1做异或操作 ~x =  x^0x FFFFFFFF   3、两个比较有趣的式子：(n ^(n+1)) 和 ((n ^(n-1))+1)>>1   （1）首先来看(n ^(n+1))这个式子，假设n = 10011010， n+1 = 10011011，则：   10011010---àn xor    10011011---àn+1 ------------------------------------       00000001---àans   如果还不能看出什么的话，再来一个例子：n = 11111111， n+1 = 100000000，则：   11110111---àn xor     11111000---àn+1 -------------------------       000001111---àans   得到的结果为n的倒数出现第一个0的位以及后面所有的1全部变成1，其它位都为0的数。     （2）再来看看((n ^(n-1))+1)>>1这个式子 假设n = 10011010， n-1 = 10011001，则：   10011010---àn xor    10011001---àn-1 -----------------------------------------       00000011---àans ans+1 >> 1  = 000000100 >> 1 = 000000010    看出来了吧，也就是取出n出现倒数第一个1的位及该位后面的0组成的数   4、统计n中1的奇偶性   思路：我们在按位与运算的时候学过了怎么计算一个整数中1的个数，但是我们现在用xor来解决吧： x  =  x  ^  (x >> 1 ); x  =  x  ^  (x >> 2 ); x  =  x  ^  (x >> 4 ); x  =  x  ^  (x >> 8 ); x  =  x  ^  (x >> 16 ); return  x & 1 ;   说道这里，顺便提一下怎么求解一个数n的前导0的个数，下面的代码来自Hacker's Delight 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; } // 代码自己慢慢理解吧