Hamming Weight的算法分析

看代码时遇到一个求32bit二进制数中1的个数的问题，感觉算法很奇妙，特记录学习心得于此，备忘。

计算一个64bit二进制数中1的个数。

解决这个问题的算法不难，很自然就可以想到，但是要给出问题的最优解，却很有难度。

通常，最容易想到的算法是除余法，继而考虑到除法的代价较高，而且除数是2，会想到使用向右移位来代替除法，并使用&0x1操作来取末位的值，这样提高了算法的效率。然而，这样仍然进行了63次&操作、63次移位操作和63次+操作。若假设字长大小不限，记作N，那么上述算法的时间复杂度都为O(N)。

当然，还有更优的算法。

这个问题其实是HammingWeight的一个应用，又叫做populationcount,popcountorsidewayssum。HammingWeight详见http://en.wikipedia.org/wiki/Hamming_weight，以下部分内容取自维基百科。

Hammingcode是指一个字串中非0符号的个数（TheHamming weight of a stringis the number of symbols that are different from the zero-symbol ofthealphabetused.）。应用到2进制符号序列中来，即二进制串中1的个数就是该串的Hammingcode.那么上述的问题即转换成求解字串的Hammingcode的问题。

下面对维基百科上给出的算法，进行分析。算法使用c语言实现。

[cpp] view plaincopy

  1. //types and constants used in the functions below
  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. //This is a naive implementation, shown for comparison,
  12. //and to help in understanding the better functions.
  13. //It uses 24 arithmetic operations (shift, add, and).
  14. int popcount_1(uint64 x) {
  15. x = (x & m1 ) + ((x >>  1) & m1 ); //put count of each  2 bits into those  2 bits
  16. x = (x & m2 ) + ((x >>  2) & m2 ); //put count of each  4 bits into those  4 bits
  17. x = (x & m4 ) + ((x >>  4) & m4 ); //put count of each  8 bits into those  8 bits
  18. x = (x & m8 ) + ((x >>  8) & m8 ); //put count of each 16 bits into those 16 bits
  19. x = (x & m16) + ((x >> 16) & m16); //put count of each 32 bits into those 32 bits
  20. x = (x & m32) + ((x >> 32) & m32); //put count of each 64 bits into those 64 bits
  21. return x;
  22. }

分析：popcount1是下面算法的基础，理解了这个算法的思想，下面的算法不过就是此算法的局部优化罢了。
首先，理解这样一个事实，64bit的二进制串中最多有64个1，而0~64内的值必然可以使用该串的低8位来表示（2^8>64）。2^2>2,那么2bit的串中的1的个数必然可以用这两位来表示。
我们先简化成8bit的串，来描述算法的基本思想。
使用abcdefgh来代表一个8bit的2进制串，其中a,b,c,d,e,f,g,h属于集合{0,1}
那么算法求解的目标输出是out=a+b+c+d+e+f+g+h
对应到上面代码中的第一步来说，x = (x & m1 ) + ((x >> 2) & m1 )，
x&m1 = 0b0d0f0h
(x>>2)&m1 = 0a0c0e0g
求和得到：[a+b]2[c+d]2[e+f]2[g+h]2,这里[x]2 表示2位的二进制，其值=x(x表示10进制的值)。如果对应到64bit的串，那么这里将有32个2-bit的组合，即将64bit两两一组，并使用其来表示自身包含的1的个数。

代码的第二步：x = (x & m2 ) + ((x >> 4) & m2 ),同样使用8bit串来简化描述。
x&m2 = 00[c+d]200[g+h]2
(x>>4)&m2 = 00[a+b]2 00[e+f]2
求和得到：[a+b+c+d]4[e+f+g+h]4

第三步： x = (x & m4 ) + ((x >> 4) & m4 );
x&m4 = 0000[e+f+g+h]4
(x>>4)&m2 = 0000[a+b+c+d]4
求和得到：[a+b+c+d+e+f+g+h]8
至此问题得解。对于64bit的串，则如代码所示还要多进行3步。

到这里可以很清楚的看到，算法是使用了分治的思想，每步将问题划分成子问题，然后合并来减小问题的规模，求解问题的过程像是一棵倒置的二叉树。先将n位的二进制相邻的两位两两分为一组，并巧妙的利用移位和掩码来使其利用自身来表示所得到的和，这样从宏观上来看，问题就被简化成规模为n/2bit(这里的bit其实已经是虚指了，其实理解为unit更好)的问题求解了，同样的，继续两两划分成一组分治求解。经过lg（n）步，得到最终的解。
由以上分析可见，算法的复杂度为O（lgn）。
对于64位的字串来说 ，只使用了24次算数操作，比起前面的算法来说要明显减少了。

[cpp] view plaincopy

  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效果应该一样的吧..?)

[cpp] view plaincopy

  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的值，得解。

此外还有比较有趣的算法：

[cpp] view plaincopy

  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的循环

[cpp] view plaincopy

  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. //Use this instead if most bits in x are 1 instead of 0
  18. #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的串，也可以使用分成两部分查表的方法来节省一点内存：

static unsigned char wordbits[65536] = { bitcounts of ints between 0 and 65535 };
static int popcount(uint32 i)
{
    return (wordbits[i&0xFFFF] + wordbits[i>>16]);
}

Hamming Weight还有很多应用，这里只是简单记录一下它在求解popcount上的用法。

时间： 2024-10-10 07:05:20

Hamming Weight的算法分析的相关文章

Hamming Weight的算法分析（转载）

看代码时遇到一个求32bit二进制数中1的个数的问题,感觉算法很奇妙,特记录学习心得于此,备忘. 计算一个64bit二进制数中1的个数. 解决这个问题的算法不难,很自然就可以想到,但是要给出问题的最优解,却很有难度. 通常,最容易想到的算法是除余法,继而考虑到除法的代价较高,而且除数是2,会想到使用向右移位来代替除法,并使用&0x1操作来取末位的值,这样提高了算法的效率.然而,这样仍然进行了63次&操作.63次移位操作和63次+操作.若假设字长大小不限,记作N,那么上述算法的时间复杂度都为

leedcode 191 Hamming Weight

191. For example, the 32-bit integer ’11' has binary representation 00000000000000000000000000001011, so the function should return 3. Java code int hammingweight(int n)  //因为是32位,所以n要看做无符号整数 { int sum =0; while(n!=0){ if(n&1==1) sum++; n>>>1

相似算法 ，Java实例9 - 汉明距离 Hamming Distance

Java实例9 - 汉明距离 Hamming Distance http://blog.csdn.net/kindterry/article/details/6581344 /**在信息理论中,两个等长字符串之间的汉明距离 * 是两个字符串对应位置上不同字符的个数, * 换句话说,汉明距离就是将一个字符串替换成另外一个字符串所需要替换的字符长度. *例如,1011101和1001001之间的汉明距离是2, *toned和roses之间的汉明距离是3. *汉明重量是字符串相对于同样长度的零字符串的

海明距离hamming distance

仔细阅读ORB的代码,发现有很多细节不是很明白,其中就有用暴力方式测试Keypoints的距离,用的是HammingLUT,上网查了才知道,hamming距离是相差位数.这样就好理解了. 我理解的HammingLUT lut; result=lut((a),(b),size_t size):result=a与b的hamming distance+size; [cpp] view plain copy print? unsigned int hamdist(unsigned int x, unsi

[LeetCode]Reverse Bits

题目:Reverse Integer Reverse digits of an integer. Example1: x = 123, return 321Example2: x = -123, return -321 Have you thought about this? Here are some good questions to ask before coding. Bonus points for you if you have already thought through thi

位运算操作

来源:https://discuss.leetcode.com/topic/50315/a-summary-how-to-use-bit-manipulation-to-solve-problems-easily-and-efficiently/2 WIKI Bit manipulation is the act of algorithmically manipulating bits or other pieces of data shorter than a word. Computer p

338. 1的位数 Counting Bits

Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ num calculate the number of 1's in their binary representation and return them as an array. Example:For num = 5 you should return [0,1,1,2,1,2]. Follow up: It is very e

191. 求1的位数 Number of 1 Bits

Write a function that takes an unsigned integer and returns the number of '1' bits it has (also known as the Hamming weight). For example, the 32-bit integer '11' has binary representation 00000000000000000000000000001011, so the function should retu

LeetCode OJ：Number of 1 Bits（比特1的位数）

Write a function that takes an unsigned integer and returns the number of ’1' bits it has (also known as the Hamming weight). For example, the 32-bit integer ’11' has binary representation 00000000000000000000000000001011, so the function should retu