C/C++位操作技巧
来源：互联网 发布：淘宝情侣店铺推荐 编辑：程序博客网 时间：2024/05/20 05:07
检测一个无符号数是不为2^n-1(^为幂)： x&(x+1) 将最右侧0位改为1位： x | (x+1) 二进制补码运算公式： -x = ~x + 1 = ~(x-1) ~x = -x-1 -(~x) = x+1 ~(-x) = x-1 x+y = x - ~y - 1 = (x|y)+(x&y) x-y = x + ~y + 1 = (x|~y)-(~x&y) x^y = (x|y)-(x&y) x|y = (x&~y)+y x&y = (~x|y)-~x x==y: ~(x-y|y-x) x!=y: x-y|y-x x< y: (x-y)^((x^y)&((x-y)^x)) x<=y: (x|~y)&((x^y)|~(y-x)) x< y: (~x&y)|((~x|y)&(x-y))//无符号x,y比较 x<=y: (~x|y)&((x^y)|~(y-x))//无符号x,y比较 使用位运算的无分支代码： 计算绝对值 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时失败(^为幂) } 三值比较：cmp(x,y) = -1, x<y; 0, x==y; 1, x > y int cmp( int x, int y ) { return (x>y)-(x-y) ; } doz=x-y, x>=y; 0, x<y int doz(int x, int y ) { int d ; d = x-y ; return d & ((~(d^((x^y)&(d^x))))>>31) ; } int max(int x, int y ) { int m ; m = (x-y)>>31 ; return y & m | x & ~m ; } 不使用第三方交换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 ; 双值交换:x = a, x==b; b, x==a//常规编码为x = x==a ? b :a ; 1.x = a+b-x ; 2.x = a^b^x ; 下舍入到2的k次方的倍数: 1.x & ((-1)<<k) 2.(((unsigned)x)>>k)<<k 上舍入： 1. t = (1<<k)-1 ; x = (x+t)&~t ; 2.t = (-1)<<k ; x = (x-t-1)&t ; 位计数,统计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 ; } 递增位反转后的数： unsigned inc_r(unsigned x) { unsigned m = 0x80000000 ; x ^= m ; if( (int)x >= 0 ) do { m >>= 1 ; x ^= m ; } while( x < m ) ; return x ; } 混选位： abcd efgh ijkl mnop ABCD EFGH IJKL MNOP->aAbB cCdD eEfF gGhH iIjJ kKlL mMnN oOpP unsigned ps(unsigned x) { unsigned t ; t = (x ^ (x>>8)) & 0x0000ff00; x = x ^ t ^ (t<<8) ; t = (x ^ (x>>4)) & 0x00f000f0; x = x ^ t ^ (t<<4) ; t = (x ^ (x>>2)) & 0x0c0c0c0c; x = x ^ t ^ (t<<2) ; t = (x ^ (x>>1)) & 0x22222222; x = x ^ t ^ (t<<1) ; return x ; } 位压缩： 选择并右移字x中对应于掩码m的1位的位,如：compress(abcdefgh,01010101)=0000bdfh compress_left(x,m)操作与此类似，但结果位在左边: bdfh0000. unsigned compress(unsigned x, unsigned m) { unsigned mk, mp, mv, t ; int i ; x &= m ; mk = ~m << 1 ; for( i = 0 ; i < 5 ; ++i ) { mp = mk ^ ( mk << 1) ; mp ^= ( mp << 2 ) ; mp ^= ( mp << 4 ) ; mp ^= ( mp << 8 ) ; mp ^= ( mp << 16 ) ; mv = mp & m ; m = m ^ mv | (mv >> (1<<i) ) ; t = x & mv ; x = x ^ t | ( t >> ( 1<<i) ) ; mk = mk & ~mp ; } return x ; } 位置换： 用32个5位数表示从最低位开始的位的目标位置，结果是一个32*5的位矩阵， 将该矩阵沿次对角线转置后用5个32位字p[5]存放。 SAG(x,m) = compress_left(x,m) | compress(x,~m) ; 准备工作： void init( unsigned *p ) { p[1] = SAG( p[1], p[0] ) ; p[2] = SAG( SAG( p[2], p[0]), p[1] ) ; p[3] = SAG( SAG( SAG( p[3], p[0] ), p[1]), p[2] ) ; p[4] = SAG( SAG( SAG( SAG( p[4], p[0] ), p[1]) ,p[2]), p[3] ) ; } 实际置换： int rep( unsigned x ) { x = SAG(x,p[0]); x = SAG(x,p[1]); x = SAG(x,p[2]); x = SAG(x,p[3]); x = SAG(x,p[4]); return x ; } 二进制码到GRAY码的转换: unsigned B2G(unsigned B ) { return B ^ (B>>1) ; } GRAY码到二进制码: unsigned G2B(unsigned G) { unsigned B ; B = G ^ (G>>1) ; B = G ^ (G>>2) ; B = G ^ (G>>4) ; B = G ^ (G>>8) ; B = G ^ (G>>16) ; return B ; } 找出最左0字节的位置: int zbytel( unsigned x ) { static cahr table[16] = { 4,3,2,2, 1,1,1,1, 0,0,0,0, 0,0,0,0 } ; unsigned y ; y = (x&0x7f7f7f7f) + 0x7f7f7f7f ; y = ~(y|x|0x7f7f7f7f) ; return table[y*0x00204081 >> 28] ;//乘法可用移位和加完成 } ------------------------------------------------------------------------------------------------------------------------------------------
按位与（AND）& 操作
由于位运算直接对内存数据进行操作，不需要转成十进制，因此处理速度非常快。
按位与（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的个数可以这样数：
{
//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 .求得。
具体实现如下：
使用秦九韶算法思想进行快速幂模算法，简洁漂亮
__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>>2);
x = x ^ (x>>4);
x = x ^ (x>>8);
x = x ^ (x>>16);
return x&1;
说道这里，顺便提一下怎么求解一个数n的前导0的个数，下面的代码来自Hacker's Delight
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;
}//代码自己慢慢理解吧
- C/C++位操作技巧
- C/C++位操作技巧
- C/C++位操作技巧
- C语言位操作技巧
- C/C++位操作技巧
- C/C++位操作技巧
- C/C++位操作技巧
- C/C++位操作技巧
- C/C++位操作技巧
- C语言-位操作技巧
- [总结] C语言的位操作技巧
- C/C++位操作技巧 【转载】
- C 语言中位操作技巧
- c语言-编程位操作技巧
- C语言中的位操作使用技巧
- C/C++中的位操作的技巧
- C/C bit 位操作
- C的位操作
- Dynamics CRM 通过PowerShell启用AllowDeclarativeWorkflows即自定义XAML WorkFlows
- UITableViewCell移动
- 《DOOM启世录(纪念版) 》此书出了纪念版，好像内容没变
- Oracle数据库用模糊查询、或者= 怎么得不到汉字的搜索结果?
- mongodb命令
- C/C++位操作技巧
- Java开源框架集（全）
- mybatis oracle 返回插入的主键序列号
- Spring boot 设置500 404错误的java方法
- 漫威漫画公司（Marvel Comics）简介
- OC-小知识点
- 【第8周 项目1 - 建立顺序串的算法库】
- log4j 教程
- 原来WPF默认处理了这么多Exception，见识了
