一、题目描述
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 return 3.
思路:先将十进制数转化为二进制,然后统计1的个数
c++代码(10ms)
class Solution {
public:
int hammingWeight(uint32_t n) {
vector<int> result;
while(n){
result.push_back(n%2);
n /= 2;
}
return count(result.begin(), result.end(), 1);
}
};
用到STL中的count函数,头文件为#include<algorithm>,这个函数使用一对迭代器和一个值作为参数,返回这个值出现次数的统计结果。
形式为: count(iter.begin(), iter.end(), searchValue)
后来仔细一想,在算n%2时,只要是1就计数即可,不需要用到vector,可以缩小时间,代码如下:(4ms)
class Solution {
public:
int hammingWeight(uint32_t n) {
int count = 0;
while(n){
if(n%2 == 1)
count ++ ;
n/=2;
}
return count;
}
};
其他方法:
代码1
跟我写的代码思想差不多,只不过我用的是n%2来提取余数,n/2来获取下一个要算的值。这里是通过与操作每次去掉一个1来统计。
int hammingWeight(uint32_t n)
{
int res = 0;
while(n)
{
n &= n - 1;
++ res;
}
return res;
}
代码2
32位二进制,每次通过与一下00000000000000000000000000000001,如果结果不为0则计数一次,否则不计数。
def hammingWeight(self, n):
rst = 0
mask = 1
for i in range(32):
if n & mask:
rst += 1
mask = mask << 1
return rst
代码3
建立一棵树
// This is a naive implementation, shown for comparison, and to help in understanding the better functions.
// It uses 24 arithmetic operations (shift, add, and).
int hammingWeight(uint32_t n)
{
n = (n & 0x55555555) + (n >> 1 & 0x55555555); // put count of each 2 bits into those 2 bits
n = (n & 0x33333333) + (n >> 2 & 0x33333333); // put count of each 4 bits into those 4 bits
n = (n & 0x0F0F0F0F) + (n >> 4 & 0x0F0F0F0F); // put count of each 8 bits into those 8 bits
n = (n & 0x00FF00FF) + (n >> 8 & 0x00FF00FF); // put count of each 16 bits into those 16 bits
n = (n & 0x0000FFFF) + (n >> 16 & 0x0000FFFF); // put count of each 32 bits into those 32 bits
return n;
}
// This uses fewer arithmetic operations than any other known implementation on machines with slow multiplication.
// It uses 17 arithmetic operations.
int hammingWeight(uint32_t n)
{
n -= (n >> 1) & 0x55555555; //put count of each 2 bits into those 2 bits
n = (n & 0x33333333) + (n >> 2 & 0x33333333); //put count of each 4 bits into those 4 bits
n = (n + (n >> 4)) & 0x0F0F0F0F; //put count of each 8 bits into those 8 bits
n += n >> 8; // put count of each 16 bits into those 8 bits
n += n >> 16; // put count of each 32 bits into those 8 bits
return n & 0xFF;
}
// This uses fewer arithmetic operations than any other known implementation on machines with fast multiplication.
// It uses 12 arithmetic operations, one of which is a multiply.
int hammingWeight(uint32_t n)
{
n -= (n >> 1) & 0x55555555; // put count of each 2 bits into those 2 bits
n = (n & 0x33333333) + (n >> 2 & 0x33333333); // put count of each 4 bits into those 4 bits
n = (n + (n >> 4)) & 0x0F0F0F0F; // put count of each 8 bits into those 8 bits
return n * 0x01010101 >> 24; // returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24)
}