最容易想到的算法是除余法，继而考虑到除法的代价较高，而且除数是2，
会想到使用向右移位来代替除法，并使用&0x1操作来取末位的值，这样提高了算法的效率。
然而，这样仍然进行了63次&操作、63次移位操作和63次+操作。若假设字长大小不限，记作N，那么上述算法的时间复杂度都为O(N)。
具体实现方法：
1.除以2，逐个数，遍历。
1 class HammingWeight{ 2 public: 3 int HammingWeight(uint32_t n){ 4 int cnt=0; 5 while(n!=0) 6 { 7 if(n%2==1) //满足尾数为1 8 cnt++; 9 n/=2;//除以2，右移一位 10 } 11 12 return cnt; 13 } 14 15 };
2.位操作：
1 class HammingWeight{ 2 public: 3 int HammingWeight(uint32_t n){ 4 int cnt=0; 5 while(n!=0) 6 { 7 cnt+=n&1;//尾数按位与1 8 n>>=1;//右移一位 9 } 10 return cnt; 11 } 12 }
因此，对于任何一个整数n（对应的二进制数有位），它都要进行
次判断。可以说，算法效率比较低，每一位都进行了判断。
3.n&=n-1
n&=n-1, 只与二进制中1的位数相关的算法
考虑每次找到最低位开始遇到的第一个1，计数，再把它清零，清零的位运算操作是&0，
但是在有1的这一位&0的操作，要同时不影响未统计过的位数和已经统计过的位数，因此有 n&=n-1这样的方法。
该操作对比当前操作位高的位没有影响，对低位则完全清零。
比如：
6（110），
第一次 110&101=100，这次操作成功的把从低位起第一个1消掉了，同时计数器加1。
第二次100&011=000，同理又统计了高位的一个1，此时n已变为0，不需要再继续了，于是110中有2个1。
1 class HammingWeight{ 2 public: 3 int HammingWeight(uint32_t n){ 4 int cnt=0; 5 whilie(n!=0) 6 { 7 n&=n-1; 8 cnt++; 9 } 10 return cnt; 11 } 12 }
精髓：n&=n-1，该操作对比当前操作位高的位没有影响，对低位则完全清零。
4.wiki上的解法
1 class HammingWeight{ 2 public: 3 int HammingWeight(uint32_t n){ 4 n=(n&0x55555555)+((n>>1)&0x55555555); 5 n=(n&0x33333333)+((n>>2)&0x33333333); 6 n=(n&0x0f0f0f0f)+((n>>4)&0x0f0f0f0f); 7 n=(n&0x00ff00ff)+((n>>8)&0x00ff00ff); 8 n=(n&0x0000ffff)+((n>>16)&0x0000ffff); 9 return n; 10 } 11 };
主要思想： 错位分段相加，然后递归合并的过程。
0x55555555 ->0101 0101 0101 0101 0101 0101 0101 0101
0x33333333 ->0011 0011 0011 0011 0011 0011 0011 0011
0x0f0f0f0f ->0000 1111 0000 1111 0000 1111 0000 1111
0x0000ffff ->0000 0000 0000 0000 1111 1111 1111 1111
因此可以看出：
整个数按照上述的周期被分成了n段，
每段里面的前半截都被清零，
后半截保留了数据。
不同在于这些数分段的长度是2倍增长的。于是我们可以姑且命名它们为“分段截取常数”。
这样，如果我们按照分段的思想，每个周期分成一段的话，
你或许就可以感觉到这个分段是二分法的倒过来——类似二段合并一样的东西！
现在回头来看问题，我们要求的是1的个数。
这就要有一个清点并相加的过程（查表法除外）。
使用&运算和移位运算可以帮我们找到1，但是却无法计算1的个数，需要由加法来完成。最传统的逐位查找并相加，每次只加了1位，显然比较浪费，我们能否一次用加法来计算多次的位数呢？
再考虑问题，找到了1的位置，如何把这个位置变成数量。
最简单的情况，一个2位的数，比如11，只要把它的第二位和第一位相加，不就得到了1的个数了吗？！所以对于2位的x，有x中1的个数=(x>>1)+(x&1)。是不是和上面的式子有点像？
再考虑稍复杂的，一个字节内的情况。
一个字节的x，显然不能用(x>>1)+(x&1)的方法来完成，
但是我们受到了启发，如果把x分段相加呢？
把x分成4个2位的段，然后相加，就会产生4个2位的数，每个都代表了x对应2位地方的1的个数。
对于n位二进制数，最多有n个1，而n必定能由n位二进制数来表示，因此我们在求出某k位中1的个数后，
可以将结果直接存储在这k位中，不需要额外的空间。
以4位二进制数abcd为例，最终结果是a+b+c+d，循环的话需要4步加法
让abcd相邻的两个数相加，也就是 a+b+c+d=[a+b]+[c+d]
[0 b 0 d]
[0 a 0 c]
--------
[e f] [ g h]
ef=a+b gh=c+d 而 0b0d=(abcd)&0101,0a0c=(abcd)>>1 &0101
[ef] [gh]再相邻的两组相加
[00 ef]
[gh]
--------
i j k l
ijkl=ef+gh gh=(efgh)&& 0011 ,ef=(efgh)>>2 & 0011
依次入次递推。需要log(N)次
例子：
若求156中1的个数，156二进制是10011100
最终：
[1][0][0][1][1][1][0][0] //初始，每一位是一组
---
|0 0 |0 1 |0 1 |0 0| //与01010101相与的结果，同时2个一组分组
+
|0 1 |0 0 |0 1 |0 0| //右移一位后与01010101相与的结果
=
[0 1][0 1][1 0][0 0] //相加完毕后，现在每2位是一组，每一组保存的都是最初在这2位的1的个数
----
|0 0 0 1 |0 0 0 0| //与00110011相与的结果，4个一组分组
+
|0 0 0 1 |0 0 1 0| //右移两位后与00110011相与的结果
=
[0 0 1 0][0 0 1 0] //相加完毕后，现在每4位是一组，并且每组保存的都是最初这4位的1的个数
----
|0 0 0 0 0 0 1 0|
+
|0 0 0 0 0 0 1 0|
=
[0 0 0 0 0 1 0 0] //最终合并为8位1组，保存的是整个数中1的个数，即4。
比如这个例子，143的二进制表示是10001111，这里只有8位，
高位的0怎么进行与的位运算也是0，所以只考虑低位的运算，按照这个算法走一次
+---+---+---+---+---+---+---+---+
| 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | <---143
+---+---+---+---+---+---+---+---+
| 0 1 | 0 0 | 1 0 | 1 0 | <---第一次运算后
+-------+-------+-------+-------+
| 0 0 0 1 | 0 1 0 0 | <---第二次运算后
+---------------+---------------+
| 0 0 0 0 0 1 0 1 | <---第三次运算后，得数为5
+-------------------------------+
这里运用了分治的思想，
先计算每对相邻的2位中有几个1，
再计算每相邻的4位中有几个1，下来8位，16位，32位，因为2^5＝32，所以对于32位的机器，5条位运算语句就够了。
像这里第二行第一个格子中，01就表示前两位有1个1，00表示下来的两位中没有1，其实同理。
再下来01+00=0001表示前四位中有1个1，同样的10+10=0100表示低四位中有4个1，
最后一步0001+0100=00000101表示整个8位中有5个1。
64位的机子：
1 class HammingWeight{ 2 typedef unsigned __int64 uint64; //assume this gives 64-bits 3 const uint64 m1 = 0x5555555555555555; //binary: 0101... 4 const uint64 m2 = 0x3333333333333333; //binary: 00110011.. 5 const uint64 m4 = 0x0f0f0f0f0f0f0f0f; //binary: 4 zeros, 4 ones ... 6 const uint64 m8 = 0x00ff00ff00ff00ff; //binary: 8 zeros, 8 ones ... 7 const uint64 m16 = 0x0000ffff0000ffff; //binary: 16 zeros, 16 ones ... 8 const uint64 m32 = 0x00000000ffffffff; //binary: 32 zeros, 32 ones 9 const uint64 hff = 0xffffffffffffffff; //binary: all ones 10 const uint64 h01 = 0x0101010101010101; //the sum of 256 to the power of 0,1,2,3... 11 12 //This is a naive implementation, shown for comparison, 13 //and to help in understanding the better functions. 14 //It uses 24 arithmetic operations (shift, add, and). 15 public: 16 int HammingWeight(uint64_t x){ 17 x = (x & m1 ) + ((x >> 1) & m1 ); //put count of each 2 bits into those 2 bits 18 x = (x & m2 ) + ((x >> 2) & m2 ); //put count of each 4 bits into those 4 bits 19 x = (x & m4 ) + ((x >> 4) & m4 ); //put count of each 8 bits into those 8 bits 20 x = (x & m8 ) + ((x >> 8) & m8 ); //put count of each 16 bits into those 16 bits 21 x = (x & m16) + ((x >> 16) & m16); //put count of each 32 bits into those 32 bits 22 x = (x & m32) + ((x >> 32) & m32); //put count of each 64 bits into those 64 bits 23 return x; 24 } 25 };
算法是使用了分治的思想，每步将问题划分成子问题，然后合并来减小问题的规模，求解问题的过程像是一棵倒置的二叉树。
先将n位的二进制相邻的两位两两分为一组，并巧妙的利用移位和掩码来使其利用自身来表示所得到的和，这样从宏观上来看，问题就被简化成规模为n/2bit(这里的bit其实已经是虚指了，其实理解为unit更好)的问题求解了，
同样的，继续两两划分成一组分治求解。经过lg（n）步，得到最终的解。
由以上分析可见，算法的复杂度为O（lgn）。
对于64位的字串来说 ，只使用了24次算数操作，比起前面的算法来说要明显减少了。
下面的实在有点不懂了，先留着。。。
优化：
1 //This uses fewer arithmetic operations than any other known 2 //implementation on machines with slow multiplication. 3 //It uses 17 arithmetic operations. 4 int popcount_2(uint64 x) { 5 x -= (x >> 1) & m1; //put count of each 2 bits into those 2 bits 6 x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits 7 x = (x + (x >> 4)) & m4; //put count of each 8 bits into those 8 bits 8 x += x >> 8; //put count of each 16 bits into their lowest 8 bits 9 x += x >> 16; //put count of each 32 bits into their lowest 8 bits 10 x += x >> 32; //put count of each 64 bits into their lowest 8 bits 11 return x & 0x7f; 12 }
popcount2在popcount1的基础上进行了优化。
第一步基于了这样一个事实:ab-0a得到的值为ab中1的个数。
简单证明：若a为0，那么0a=0,减0无变化，那么b就是结果。
若a位1，那么只有两种情况，10-01 = 01, 11-01 = 10.都符合上述事实。
这样x -= (x >> 1) & m1和 x = (x & m1 ) + ((x >> 1) & m1 )的结果相同，却节省了1个操作。（这里我有个疑问，有符号数使用补码进行减法操作等于加法操作，效率相当，然而这里x为无符号数，即原码加减法，原码的减法在机器级如何实现，即一个源码减法的操作的代价与加法和与操作的代价和比较，哪个更大？有时间的话要去看下原码减法的实现）
第二步第三步同popcount1，此时x=[a]8[b]8[c]8[d]8[e]8[f]8[g]8[h]8
第四步后x = [H8|a+b]16[H8|c+d]16[H8|e+f]16[H8|g+h]16,这里H8代表高8位，由于我们不关心高8位的值（当然H的值是明显知道的），这里就用H代替。由于使用低8位完全可以表示0～64范围内的值，因此不用担心低八位溢出。
同理，第五步后x=[H24|a+b+c+c]32[H24|e+f+g+h]32
第六步后x=[H56|e+f+g+h]64
第七步使用掩码0x7f获得低8位的值(0xff效果应该一样的吧..?)
1 //This uses fewer arithmetic operations than any other known 2 //implementation on machines with fast multiplication. 3 //It uses 12 arithmetic operations, one of which is a multiply. 4 int popcount_3(uint64 x) { 5 x -= (x >> 1) & m1; //put count of each 2 bits into those 2 bits 6 x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits 7 x = (x + (x >> 4)) & m4; //put count of each 8 bits into those 8 bits 8 return (x * h01)>>56; //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... 9 }
popcount3进一步进行了优化，只看最后一步:return (x * h01)>>56;
此步之前的x=[a]8[b]8[c]8[d]8[e]8[f]8[g]8[h]8
x*h01 = x*0x0101010101010101 = x+(x<<8)+(x<<16)...+(x<<56)
即x=[a+b+c+d+e+f+g+h|L56], L56指低56位
右移56位获得a+b+c+d+e+f+h的值，得解。
1 //This is better when most bits in x are 0 2 //It uses 3 arithmetic operations and one comparison/branch per "1" bit in x. 3 int popcount_4(uint64 x) { 4 int count; 5 for (count=0; x; count++) 6 x &= x-1; 7 return count; 8 }
上面这个算法在已知0的数目比较多时候很高效。
此算法基于这样一个事实：x-1使得以二进制表示的x，从低向高位开始包括第一个1在内的值，都由0变成1，由1变成0。如11-01 = 10, 10 – 01 = 01, 01 – 01 = 00, 100 – 001 = 011。而&操作使得发生变化的位置都变成0，这样就去除了1个1，从而有几个1就&几次，最终x必变成0.
下面算法消除了popcount4的循环
1 //This is better if most bits in x are 0. 2 //It uses 2 arithmetic operations and one comparison/branch per "1" bit in x. 3 //It is the same as the previous function, but with the loop unrolled. 4 #define f(y) if ((x &= x-1) == 0) return y; 5 int popcount_5(uint64 x) { 6 if (x == 0) return 0; 7 f( 1) f( 2) f( 3) f( 4) f( 5) f( 6) f( 7) f( 8) 8 f( 9) f(10) f(11) f(12) f(13) f(14) f(15) f(16) 9 f(17) f(18) f(19) f(20) f(21) f(22) f(23) f(24) 10 f(25) f(26) f(27) f(28) f(29) f(30) f(31) f(32) 11 f(33) f(34) f(35) f(36) f(37) f(38) f(39) f(40) 12 f(41) f(42) f(43) f(44) f(45) f(46) f(47) f(48) 13 f(49) f(50) f(51) f(52) f(53) f(54) f(55) f(56) 14 f(57) f(58) f(59) f(60) f(61) f(62) f(63) 15 return 64; 16 } 17 18 //Use this instead if most bits in x are 1 instead of 0 19 #define f(y) if ((x |= x+1) == hff) return 64-y;
最有趣的是查表法，当有足够的内存时，我们可以用空间换时间，从而得到O(1)的最优算法。
以4bit的串为例，可以构造一个数组int counts[16]={0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4}.
对于4bit的x,x的hamming weight即为：counts[x].
对于32bit的串，也可以使用分成两部分查表的方法来节省一点内存：
1 static unsigned char wordbits[65536] = { bitcounts of ints between 0 and 65535 }; 2 static int popcount(uint32 i) 3 { 4 return (wordbits[i&0xFFFF] + wordbits[i>>16]); 5 }
原文：http://www.cnblogs.com/jawiezhu/p/4395063.html