剑指Offer--010-二进制中1的个数

链接 ——-

牛客OJ:二进制中1的个数

九度OJ:http://ac.jobdu.com/problem.php?pid=1513

GitHub代码: 010-二进制中1的个数

CSDN题解:剑指Offer–010-二进制中1的个数

牛客OJ 九度OJ CSDN题解 GitHub代码
二进制中1的个数 1513-二进制中1的个数 剑指Offer–010-二进制中1的个数 010-二进制中1的个数

题意

题目描述

输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。

样例输入

3
4
5
-1

样例输出

1
2
32

通过移位测试每一位

我们很容易想到的算法就是

通过移位的方法,挨个判断其每一位

class Solution
{
public:
    int NumberOf1(int n)
    {
        int count = 0;

        while(n)
        {
            if(n & 1 == 1)
            {
                count++;
            }
            n >>= 1;
        }
        return count;
    }
};

但是这个算法有致命的缺陷,我们假设通过移位的方式可以获取到其每一位,但是并不总是对的

逻辑右移与算术右移

比如一个有符号位的8位二进制数11001101,逻辑右移就不管符号位,如果移一位就变成01100110。算术右移要管符号位,右移一位变成10100110。

  • 逻辑左移=算数左移,右边统一添0
  • 逻辑右移,左边统一添0
  • 算数右移,左边添加的数和符号有关

e.g:1010101010,其中[]位是添加的数字

逻辑左移一位:010101010[0]

算数左移一位:010101010[0]

逻辑右移一位:[0]101010101

算数右移一位:[1]101010101

因此如果输入负数,那么我们的算法简单的判断是不是0来终结,岂不是要死循环

避免负数移位的死循环

为了负数时候避免死循环,我们可以不右移数字n,转而去移动测试位

那么思考我们的循环结束条件,flag一直左移(乘以2),当超出表示标识范围的时候,我们就可以终止了,但是这样子的话,最高位的符号位没有测试,因此要单独测试,同时由于会溢出,我们的flag需要用long来标识

类型 范围
unsigned int 0~4294967295
int 2147483648~2147483647
unsigned long 0~4294967295

| long |2147483648~2147483647|

| long long|最大值:9223372036854775807|

| long long|最小值:-9223372036854775808|

| unsigned long long|最大值:1844674407370955161|

| __int64|最大值:9223372036854775807|

| __int64|最小值:-9223372036854775808|

| unsigned __int64|最大值:18446744073709551615

代码如下

class Solution
{
public:
    int NumberOf1(int n)
    {
        int count = 0;
        int i = 0;
        unsigned long flag = 1;

        while(flag <= INT_MAX)
        {
            debug <<n <<" & " <<flag <<" == "<<(n & flag) <<endl;
            if((n & flag) != 0)
            {
                count++;
            }
            flag <<= 1;
        }

        // 由于循环终结,我们使用的是flag <= INT_MAX
        // 因此前面的循环只会执行31次
        if((n & flag) != 0)    // 最后测试符号位
        {
            count++;
        }

        return count;
    }

};

继续考虑,有没有什么能够精简我们的循环条件,
考虑这点,如果数据发生溢出的话,会被截断,截断以后是多少呢,0
代码如下

class Solution
{
public:
    int NumberOf1(int n)
    {
        int count = 0;
        int i = 0;
        unsigned int flag = 1;

        while(flag != 0)
        {
            debug <<n <<" & " <<flag <<" == "<<(n & flag) <<endl;
            if((n & flag) != 0)
            {
                count++;
            }
            flag <<= 1;
        }
        debug <<n <<" & " <<flag <<" == "<<(n & flag) <<endl;

        return count;
    }

};

这种方法循环的次数正好是是整数二进制数的位数,比如int就是32位循环32次

那么有没有一种方法,整数中有几个1就循环几次呢?

整数中有几个1就循环几次–lowbit优化

我们分析n以n-1两个数的差别,

  • 如果n!=0,那么其二进制位中至少有一个1

  • 如果n的最低位是1(奇数),那么n-1正好把这个最低位的1变成0,其他位不变

  • 如果n的最低位是0(偶数),那么假设其右起第一个1位于m位,即m位后面全是0,那么n-1的第m位由1变成0,而第m位后面的所有0均变成1,m位之前的所有位保持不变。

因此通过分析发现:

把一个整数n减去1,再和原来的整数做与运算,会把该整数最右边一个1变成0,那么该整数有多少个1,就会进行多少次与运算

即循环的次数,即二进制中1的个数

如果一个整数不为0,那么这个整数至少有一位是1。如果我们把这个整数减1,那么原来处在整数最右边的1就会变为0,原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。
举个例子:一个二进制数1100,从右边数起第三位是处于最右边的一个1。减去1后,第三位变成0,它后面的两位0变成了1,而前面的1保持不变,因此得到的结果是1011.我们发现减1的结果是把最右边的一个1开始的所有位都取反了。这个时候如果我们再把原来的整数和减去1之后的结果做与运算,从原来整数最右边一个1那一位开始所有位都会变成0。如1100&1011=1000.也就是说,把一个整数减去1,再和原整数做与运算,会把该整数最右边一个1变成0.那么一个整数的二进制有多少个1,就可以进行多少次这样的操作。

#include <iostream>

using namespace std;

// 调试开关
#define __tmain main

#ifdef __tmain

#define debug cout

#else

#define debug 0 && cout

#endif // __tmain


class Solution
{
public:
    int NumberOf1(int n)
    {
        int count = 0;
        while(n)
        {
            count++;
            n = n & (n - 1);
        }

        return count;
    }

};


#include <cmath>

int __tmain( )
{
    cout <<sizeof(long) <<endl;
    Solution solu;
    cout <<solu.NumberOf1(1) <<endl;;
    cout <<solu.NumberOf1(2) <<endl;;
    cout <<solu.NumberOf1(-2147483648) <<endl;;

    return 0;
}

STL-bitset

STL中用来方便地管理一系列的bit位而不用程序员自己来写代码。
bitset除了可以访问指定下标的bit位以外,还可以把它们作为一个整数来进行某些统计

class Solution
{
public:
    int NumberOf1(int n)
    {
        bitset<32> bit(n);
        return bit.count();

    }

};

你可能感兴趣的:(github,算法,bitset,二进制,面试)