第2章 数字之魅——求二进制中1的个数

求二进制中1的个数

问题描述

  对于一个字节(8bit)的变量,求其二进制表示中“1”的个数,要求算法的执行效率尽可能地高。

【解法一】

  可以举一个八位的二进制例子来进行分析。对于二进制操作,我们知道,除以一个2,原来的数字将会减少一个0。如果除的过程中有余,那么就表示当前位置有一个1。

以10 100 010为例;

第一次除以2时,商为1 010 001,余为0。

第二次除以2时,商为101 000,余为1。

因此,可以考虑利用整型数据除法的特点,通过相除和判断余数的值来进行分析。于是有了如下的代码:

 1 package chapter2shuzizhimei.erjinzhicount1;
 2 /**
 3  * 求二进制数中1的个数
 4  * 【方法一】
 5  * @author DELL
 6  *
 7  */
 8 public class Count1 {
 9
10     /**
11      * 统计整数x转变成二进制后1的个数
12      * @param x 被计算的整数
13      * @return 二进制中1的个数
14      */
15     public static int count(int x){
16         int count = 0;  //记录二进制中1的个数
17         while(x!=0){
18             if(x%2==1){
19                 count++;
20             }
21             x /= 2;
22         }
23         return count;
24     }
25
26     public static void main(String[] args){
27         int x = 15;
28         System.out.println("二进制中1的个数为:"+count(x));
29     }
30 }

程序运行结果如下:

二进制中1的个数为:4

【解法二】采用位操作

  前面的代码看起来比较复杂。我们知道,向右移位操作同样也可以达到相除的目的。唯一不同之处在于,移位之后如何来判断是否有1存在。对于这个问题,再来看看一个八位的数字:10 100 001。

  在向右移位的过程中,我们会把最后一位直接丢弃。因此,需要判断最后一位是否为1,而"与"操作可以达到目的。可以把这个八位的数字与00000001进行"与"操作。如果结果为1,则表示当前八位数的最后一位为1,否则为0。代码如下:

 1 package chapter2shuzizhimei.erjinzhicount1;
 2 /**
 3  * 求二进制数中1的个数
 4  * 【方法二】采用位操作
 5  * @author DELL
 6  *
 7  */
 8 public class Count2 {
 9
10     /**
11      * 统计整数x转变成二进制后1的个数
12      * @param x 被计算的整数
13      * @return 二进制中1的个数
14      */
15     public static int count(int x){
16         int count = 0;  //记录二进制中1的个数
17         while(x!=0){
18             count += x&0x01;  //采用与运算来统计1的个数
19             x >>= 1;
20         }
21         return count;
22     }
23
24     public static void main(String[] args){
25         int x = 15;
26         System.out.println("二进制中1的个数为:"+count(x));
27     }
28 }

程序运行结果如下:

二进制中1的个数为:4

【解法三】 只考虑1的个数

  位操作比除、余操作的效率高了很多。但是,即使采用位操作,时间复杂度仍为O(log2v),log2v为二进制数的位数。那么,还能不能再降低一些复杂度呢?如果有办法让算法的复杂度只与"1"的个数有关,复杂度不就能进一步降低了吗?

  同样用10 100 001来举例。如果只考虑和1的个数相关,那么,我们是否能够在每次判断中,仅与1来进行判断呢?

  为了简化这个问题,我们考虑只有一个1的情况。例如:01 000 000。

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

  如果希望操作后的结果为0,01 000 000可以和00 111 111进行"与"操作。

  这样,要进行的操作就是 01 000 000 &(01 000 000 - 00 000 001)= 01 000 000 &00 111 111 = 0。

  因此就有了解法三的代码:

 1 package chapter2shuzizhimei.erjinzhicount1;
 2 /**
 3  * 求二进制数中1的个数
 4  * 【方法三】只考虑1的个数减少时间复杂度
 5  * @author DELL
 6  *
 7  */
 8 public class Count3 {
 9
10     /**
11      * 统计整数x转变成二进制后1的个数
12      * @param x 被计算的整数
13      * @return 二进制中1的个数
14      */
15     public static int count(int x){
16         int count = 0;  //记录二进制中1的个数
17         while(x!=0){
18             x &= (x-1);  //消掉最高位的1
19             count++;
20         }
21         return count;
22     }
23
24     public static void main(String[] args){
25         int x = 15;
26         System.out.println("二进制中1的个数为:"+count(x));
27     }
28 }

程序运行结果如下:

二进制中1的个数为:4

【解法四】使用分支操作

  解法三的复杂度降低到O(M),其中M是v中1的个数,可能会有人已经很满足了,只用计算1的位数,这样应该够快了吧。然而我们说既然只有八位数据,索性直接把0~255的情况都罗列出来,并使用分支操作,可以得到答案,代码如下:

 1 int count(int x)
 2 {
 3     int num = 0;
 4     switch (x)
 5     {
 6         case 0x0:
 7             num = 0;
 8             break;
 9         case 0x1:
10         case 0x2:
11         case 0x4:
12         case 0x8:
13         case 0x10:
14         case 0x20:
15         case 0x40:
16         case 0x80:
17             num = 1;
18             break;
19         case 0x3:
20         case 0x6:
21         case 0xc:
22         case 0x18:
23         case 0x30:
24         case 0x60:
25         case 0xc0:
26             num = 2;
27             break;
28             //...
29     }
30     return num;
31 } 

  解法四看似很直接,但实际执行效率可能会低于解法二和解法三,因为分支语句的执行情况要看具体字节的值,如果a =0,那自然在第1个case就得出了答案,但是如果a =255,则要在最后一个case才得出答案,即在进行了255次比较操作之后!

  看来,解法四不可取!但是解法四提供了一个思路,就是采用空间换时间的方法,罗列并直接给出值。如果需要快速地得到结果,可以利用空间或利用已知结论。这就好比已经知道计算1+2+ … +N的公式,在程序实现中就可以利用公式得到结论。

【解法五】查表法

  算法中不需要进行任何的比较便可直接返回答案,这个解法在时间复杂度上应该能够让人高山仰止了。

  代码如下:

 1 int countTable[256] =
 2 {
 3          0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
 4          1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
 5          1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
 6          2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 7          1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
 8          2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 9          2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
10          3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
11          1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
12          2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
13          2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
14          3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
15          2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
16          3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
17          3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
18          4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
19 };
20
21 int count(int v)
22 {
23     return countTable[v];
24 }

  这是个典型的空间换时间的算法,把0~255中"1"的个数直接存储在数组中,v作为数组的下标,countTable[v]就是v中"1"的个数。算法的时间复杂度仅为O(1)。

  在一个需要频繁使用这个算法的应用中,通过"空间换时间"来获取高的时间效率是一个常用的方法,具体的算法还应针对不同应用进行优化。

扩展问题

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

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

  这个问题其实就是比问题1多了一个步骤,只要先算出A和B的异或结果,然后求这个异或值中1的个数就行了。

时间: 2024-10-29 19:06:23

第2章 数字之魅——求二进制中1的个数的相关文章

求二进制中1的个数的五种方法

#include<iostream> using namespace std; //求二进制中1的个数:对于一个字节(8bit)的变量,要求算法的执行效率尽可能的高 //1,对于二进制,对2求余可得到这一位是0还是1 int count1(int v) { int num=0; while(v) { if(v%2==1) ++num; v=v/2; } return num; } //2.除2可用右移操作,提高效率,判断一位是否为1可用与来判别  int count2(int v) { int

编程之美2.1 求二进制中1的个数

最近一段的时间,一直在看编程之美之类的算法书籍,刚开始看编程之美,感觉到难度太大,有时候也不愿意去翻动这本书,不过,经过一段时间的修炼,我也彻底的喜欢上这本书了, 书中的算法涉及到很多方面,树,链表,位运算,数组,hash表应用等等. 由于最近事情也忙得差不多了,我重新写了一遍编程之美中的算法,在这里记录下来,以便以后阅读方便. 第一道题从2.1写起,这道题目难度不是很大,首先,给出这个题目的函数声明: /*2.1 求二进制中1的个数*/ int DutCountOf1InBin_1(unsig

求二进制中1的个数

#include "stdio.h" int count_one_bits(unsigned int value) {   int count=0;   while(value)   {   if(value%2==1)   {   count++;   }   value=value/2;   }   return count; } int main() { unsigned int num=0; int ret=0; scanf("%d",&num);

求一个整数的二进制中1的个数

题目:输入一个整数,求该整数的二进制表达中有多少个1.例如输入10,由于其二进制表示为1010,有两个1,因此输出2. 假设该整数为i.首先i和1做与运算,判断i的最低位是不是为1.接着把1左移一位得到2,再和i做与运算,就能判断i的次高位是不是1……这样反复左移,每次都能判断i的其中一位是不是1.基于此,我们得到如下代码 int NumberOf1_Solution(int i) { int count = 0; unsigned int flag = 1; while(flag) { if(

求一个数二进制中1的个数(优化)。判断一个数是不是2的n次方

求一个数二进制中1的个数: 一般方法: #include<stdio.h> #include<stdlib.h> int   count_one_bits(unsigned int value) { int count = 0; for (int i = 0; i < 32; i++) { if (value & 1 == 1)      (%2相当于&1) { count++; } value = value >> 1;      (右移一位相当

说一说,求一个正整数的二进制中0的个数

昨天突然看到一个算法题:一个正整数a的二进制中0的个数: 话说这是个老题了,直观的算法就每次右移一位,直到0为止:代码就省略了: 仔细想想有更好的方案么? 就是这个题可以转换成一个正整数~a的二进制中1的个数: 求1的个数这个貌似就很熟悉了吧: int num = 0; b = ~a; while(b){ num++; b = b & (b-1); } 是不是容易了许多呢 另外像java和python这种没有unsigned的语言要自己去转 b = ~a & 0x0ffff

Binary system(求区间内二进制中1的个数最多的数)

Description 给定一个范围[a,b]  (0<=a<b<=10^18) 求出该范围内二进制中1的个数最多的数,如果存在多个答案,输出最小的那个数 Input 输入数据有多组,每组数据输入两个整数a,b,表示区间[a, b]. Output 输出该区间内二进制的1最多的整数,如果有多个数二进制1的个数相同,输出最小的那个数. Sample Input 4 87 14 Sample Output 77 HINT 思路: 区间[a,b],如果a==b,输出a, 先把a,b化为二进制数

转载-求一个数转换成为二进制中1的个数

转载自:求一个数转换为二进制中1的个数 // Count1--01.cpp : 定义控制台应用程序的入口点. // #include "stdafx.h" #include <iostream> using namespace std; int coutn1(int num) { int result = 0; while (num) { result+=num&0x01;//如果是1的话,整个个数加1,如果是0的话,那么就是+0:这样就可以知道二进制中1的个数了

ACM:每行输入一个正整数n,找出与它对应的比它大的最小的且它们对应的二进制中1的个数一样多的正整数.

#include<stdio.h> //每行输入一个正整数i,找出与他对应的比它大的最小的正整数且他们的二进制中1的个数一样多. /* 样例输入: 样例输出: 1 2 2 4 3 5 4 8 78 83 0 */ //78的二进制位1001110,有4个1:83比78大且83的二进制位1001011也是4个1. int main() { int count1,count2;//count1统计原数据对应的二进制中1的个数,count2... int a[100];//存输入的数字 int i=