2.1求二进制数中1的个数

最新推荐文章于 2022-01-07 09:52:54 发布

原创最新推荐文章于 2022-01-07 09:52:54 发布 · 1.4k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#位运算 #算法 #c语言

算法之美同时被 2 个专栏收录

95 篇文章

订阅专栏

编程之美

93 篇文章

订阅专栏

本文介绍了多种求解一个字节无符号整型变量中二进制1的个数的方法，包括位运算和分治策略，重点探讨了时间复杂度为O(1)的解决方案，适用于优化算法效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

2.1求二进制数中1的个数

题目：

对于一个字节（8bit）的无符号整型变量，求其中二进制表示中“1”的个数，要求算法的执行效率尽可能高。

解法一

对于二进制操作，除以一个2，原来的数字将会减少一个0。如果除的过程中有余，那么就表示当前位置有一个1。以10100010为例：

第一次除以2时，商为1010001，余为0。第二次除以2时，商为101000，余为1。

时间复杂度为O(logv)。

代码清单2.1

//2.1
int Count_2_1(BYTE v){
    int num = 0;
    while(v){
        if(v % 2 == 1)
            num++;
        v /= 2;
    }
    return num;
}

解法二

我们知道位运算同样可以达到相除的目的。在右移位过程中，需要判断最后一位是否为1。时间复杂度为O(logv)。相比于解法一，效率提高了，但是时间复杂度没有改变。

代码清单2.2

//2.2
int Count_2_2(BYTE v){
    int num = 0;
    while(v){
        num += v & 0x01;
        v >>= 1;
    }
    return num;
}

2016-04-30补充：

考虑一种输入为负数的情况。当输入为负数时，上面代码就不能很好的运行了，因为负数的二进制表示为补码的形式（补码等于反码+1，反码等于原码所有位取反），此时v向左移位的结果填充的位仍为1，这样就会造成死循环。

我们可以换一种思路来思考，如果不移动v，而是通过一个指针flag不断地判断v的每一位是否为1，再进行1的个数统计即可。这样避免了输入为负数的死循环，而且保证了时间复杂度与上面的解法相同。

代码为：

int Count2_2_1(int n){
    int count = 0;
    int flag = 1;
    while(flag){
        if(n & flag){
            count++;
        }
        flag = flag << 1;
    }
    return count;
}

解法三

让算法的复杂度只与“1”的个数有关。考虑只一个1的情况。例如：01000000.

如何判断给定的二进制数里面有且只有一个1呢？通过判断这个数是否是2的整数次幂来实现。另外，如果只和这一个“1”进行判断，如何设计操作呢？我们知道如果进行这个操作，结果为0或1，就可以得出结论。

如果希望操作后结果为0，01000000可以和00111111进行“与”操作。

这样，要进行的操作就是01000000 & (01000000 - 00000001) = 01000000 & 00111111 = 0。

代码清单2.3

//2.3
int Count_2_3(BYTE v){
    int num = 0;
    while(v){
        v &= (v - 1);
        num++;
    }
    return num;
}

解法四

解法三的算法复杂度降低到O(M)，其中M是v中1的个数。然而，既然只有八位数据，索性把0-255的所有情况都罗列出来，并使用分支操作，可以得到答案。

代码清单2.4

//2.4
int Count_2_4(BYTE v){
    int num = 0;
    switch(v){
        case 0x00:num=0;break;
        case 0x1:
        case 0x2:
        case 0x4:
        case 0x8:
        case 0x10:
        case 0x20:
        case 0x40:
        case 0x80:num=1;break;
        //...
    }
    return num;
}

解法四看起来很直接，但实际执行效率可能会低于解法二和解法三，因为分支语句的执行情况要看具体字节的值，如果a=0，那自然在第一个case就得出了答案，但是如果a=255，则要在最后一个case（经历255次比较后）才得出答案。故而解法四并不可取，但是解法四提供了一种思路，即通过空间换时间的的方法，罗列并直接给出值。

解法五

查表法，时间复杂度O(1)。

代码清单2.5

//2.5
/* 预定义的结果表 */
int countTable[256] = {0,1,1,2,1,2,2,3,1,2,2,3/*...*/}
int Count_2_5(BYTE v){
    //check Parameter
    return countTable[v];
}

个人补充：

算法六

算法五时间复杂度已经无懈可击了，这里使用位运算给出一个算法复杂度同样为O(1)的解法。

我们以三十二位数为例，使用分治思想，将其二进制依次取每两位，四位，八位，十六位，三十二位相加，得到1的个数，那么，最后一次结果的值即代表这个三十二位数1的总数。

详细解释如下：

第一次我们把每相邻的两位加起来，得到每两位里1的个数，

比如前两位10就表示原数的前两位有2个1。

第二次我们继续两两相加，10+01=11，00+10=10，

得到的结果是00110010，它表示原数前4位有3个1，末4位有2个1。

最后一次我们把0011和0010加起来，得到的就是整个二进制中1的个数。

程序中巧妙地使用取位和右移，比如第二行中$333333的二进制为00110011001100....，用它和x做and运算就相当于以2为单位间隔取数。

右移的作用就是让加法运算的相同数位对齐。

算法不依赖数中1的个数，对于一个八位数，需要运算3次，对于一个三十二位数，需要运算5次即可。

代码清单2.6

//2.6
/*
    十六进制数依次取每两位，四位，八位，十六位，三十二位相加，得到1的个数
    那么，最后一次结果的值即代表这个三十二位数1的总数
    整个程序是一个分治的思想。
    第一次我们把每相邻的两位加起来，得到每两位里1的个数，
    比如前两位10就表示原数的前两位有2个1。
    第二次我们继续两两相加，10+01=11，00+10=10，
    得到的结果是00110010，它表示原数前4位有3个1，末4位有2个1。
    最后一次我们把0011和0010加起来，得到的就是整个二进制中1的个数。
    程序中巧妙地使用取位和右移，比如第二行中$333333的二进制为00110011001100....，用它和x做and运算就相当于以2为单位间隔取数。
    右移的作用就是让加法运算的相同数位对齐。
*/
int count_Bits2(int x){
    x= (x & 0x555555) + ((x >> 1) & 0x555555);
    x= (x & 0x333333) + ((x >> 2) & 0x333333);
    x= (x & 0xF0F0F0F) + ((x >> 4) & 0xF0F0F0F);
    x= (x & 0xFF00FF) + ((x >> 8) & 0xFF00FF);
    x= (x & 0x00FFFF) + ((x >> 16) & 0x00FFFF);
    return x;
}

扩展问题

1. 如果变量是32位的DWORD，你会使用上述哪种算法，或者改进那一个算法？

对于32位数，解法二（依赖位除法）和三（依赖1的个数）的时间复杂度不变，效率随着位数的增加而增加，解法一和四仍不可取，解法五仍为O(1)，需要先使用程序进行打表，需要(2^32)*sizeof(int)大小的数组，数组实在有点大了，故不使用这种解法。最佳的还是采用算法六，只依赖数的总位数，时间为O(1)。

2. 另一个相关的问题，给定两个正整数（二进制形式表示）A和B，问把A变为B需要改变多少位（bit）？也就是说，整数A和B的二进制表示中有多少位是不相同的？

易知，将A和B两个数进行异或处理，得到的结果数中的1的个数即为需要改变的位的个数。

如将0000 1101和0000 0100异或，得到00001001，得到的结果数中有两个1，即需要改变两位，利用前面给出的求二进制数中1的个数的算法，不难给出解法（略）。