经典面试题（1）:统计整数中1的个数
题目：给定一个无符号32位整数num，求num的二进制表示法中含1的个数？
算法一：
也是最直接的算法，我们先判断整数的最右边一位是不是1，接着把整数右移一位，原来处于右边第二位的数字现在被移到第一位了，再判断是不是1。这样每次移动一位，直到这个整数变成0为止。
typedef unsigned __int64 uint64; // 64位 int count1(uint64 num) { int count=0; while(num){ count += num & 1; num >>= 1; } return count; }
算法的复杂度为O(logn)。上面这个代码对于正整数没有问题，但是对于负数可能就会出现问题了，主要原因是循环移位造成的，现做如下改进：
int count2(uint64 num) { int count=0; uint64 flag = 1; while(flag){ if(flag & num) { count++; } flag = flag << 1; } return count; }
算法二：模式位法
如果已知大多数数据位是 0 的话，那么还有更快的算法。这些更快的算法是基于这样一种事实即 n 与 n-1 相与(&)得到的最低位永远是 0。例如：
n = n & (n -1)；考虑 n 与 n -1的二进制表示，两者相&，n-1总能将n的最低位的1，置0。
int count4(uint64 num) { int n = 0; while(num) { num &= (num-1); n++; } return n; }
维基里面给出了一种奇葩的算法，其实思想和上面的循环是一样的，只是他使用宏函数写的，乍看起来有些让人摸不着头脑，自习分析一下还是蛮简单的：
// 如果大多数位置为0则使用下面的算法比较好. // 这里使用一种利用宏的技巧，而不是使用循环，其实原理和使用循环是一样的。 // 因为最多有64个1，因此只要把（64+1）中情况全部写出来就行了 #define f(y) if ((x &= x-1) == 0) return y; // 如果是1比较多可以把宏定义成这样 // #define f(y) if ((x |= x+1) == hff) return 64-y; int count3(uint64 x) { if (x == 0) return 0; f( 1) f( 2) f( 3) f( 4) f( 5) f( 6) f( 7) f( 8) f( 9) f(10) f(11) f(12) f(13) f(14) f(15) f(16) f(17) f(18) f(19) f(20) f(21) f(22) f(23) f(24) f(25) f(26) f(27) f(28) f(29) f(30) f(31) f(32) f(33) f(34) f(35) f(36) f(37) f(38) f(39) f(40) f(41) f(42) f(43) f(44) f(45) f(46) f(47) f(48) f(49) f(50) f(51) f(52) f(53) f(54) f(55) f(56) f(57) f(58) f(59) f(60) f(61) f(62) f(63) return 64; }
过程比较简单，就是循环将末尾的1变成0，算法的复杂度就是1的个数。
算法三：分而治之法
分析，n的二进制表示中位为1的位中1，还可以表示该位的1的个数为1。基于这个计数的性质。
要求一个n位的整数的二进制的表示中1的个数：
(1) 若n为1，返回该位的值；即该位上1的个数；
(2) 若n>1时，等于其前n/2位中1的个数+后n/2位中1的个数；
下面是基于这种思想的递归实现：
int count5(uint64 num, int bitSize); int count5(uint64 num) { return count5(num, sizeof(num) * 8); } int count5(uint64 num, int bitSize) { if(bitSize == 1) { return num; } else { int shiftLen = bitSize >> 1; // 移位数 int numR = num >> shiftLen; // 取高shiftLen位数字 int numL = num & (0xffffffffffffffff >> (sizeof(num) * 8-shiftLen));// 取低shiftLen位数字 return count5(numR, shiftLen) + count5( numL, shiftLen);// 合并 } }
算法四：汉明重量
本算法参照了维基百科：
声明一些常量
const uint64 m1 = 0x5555555555555555; //binary: 0101... const uint64 m2 = 0x3333333333333333; //binary: 00110011.. const uint64 m4 = 0x0f0f0f0f0f0f0f0f; //binary: 4 zeros, 4 ones ... const uint64 m8 = 0x00ff00ff00ff00ff; //binary: 8 zeros, 8 ones ... const uint64 m16 = 0x0000ffff0000ffff; //binary: 16 zeros, 16 ones ... const uint64 m32 = 0x00000000ffffffff; //binary: 32 zeros, 32 ones ... const uint64 hff = 0xffffffffffffffff; //binary: all ones const uint64 h01 = 0x0101010101010101; //the sum of 256 to the power of 0,1,2,3...
①实现方式1：
int count6(uint64 x) { x = (x & m1 ) + ((x >> 1) & m1 ); //put count of each 2 bits into those 2 bits x = (x & m2 ) + ((x >> 2) & m2 ); //put count of each 4 bits into those 4 bits x = (x & m4 ) + ((x >> 4) & m4 ); //put count of each 8 bits into those 8 bits x = (x & m8 ) + ((x >> 8) & m8 ); //put count of each 16 bits into those 16 bits x = (x & m16) + ((x >> 16) & m16); //put count of each 32 bits into those 32 bits x = (x & m32) + ((x >> 32) & m32); //put count of each 64 bits into those 64 bits return x; }
②实现方式2：
//This uses fewer arithmetic operations than any other known //implementation on machines with slow multiplication. //It uses 17 arithmetic operations. int count7(uint64 x) { x -= (x >> 1) & m1; //put count of each 2 bits into those 2 bits x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits x = (x + (x >> 4)) & m4; //put count of each 8 bits into those 8 bits x += x >> 8; //put count of each 16 bits into their lowest 8 bits x += x >> 16; //put count of each 32 bits into their lowest 8 bits x += x >> 32; //put count of each 64 bits into their lowest 8 bits return x &0xff; }
③实现方式3：
//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 count8(uint64 x) { x -= (x >> 1) & m1; //put count of each 2 bits into those 2 bits x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits x = (x + (x >> 4)) & m4; //put count of each 8 bits into those 8 bits return (x * h01)>>56; //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... }
完整代码：
#include <iostream> using namespace std; typedef unsigned __int64 uint64; // 64位 /* * 统计一个整数中1的个数 * 作者：樊列龙 * from: * 时间：2014-01-15 */ int count1(uint64 num) { int count=0; while(num){ count += num & 1; num >>= 1; } return count; } int count2(uint64 num) { int count=0; uint64 flag = 1; while(flag){ if(flag & num) { count++; } flag = flag << 1; } return count; } // 如果大多数位置为0则使用下面的算法比较好. // 这里使用一种利用宏的技巧，而不是使用循环，其实原理和使用循环是一样的。 // 因为最多有64个1，因此只要把（64+1）中情况全部写出来就行了 #define f(y) if ((x &= x-1) == 0) return y; // 如果是1比较多可以把宏定义成这样 // #define f(y) if ((x |= x+1) == hff) return 64-y; int count3(uint64 x) { if (x == 0) return 0; f( 1) f( 2) f( 3) f( 4) f( 5) f( 6) f( 7) f( 8) f( 9) f(10) f(11) f(12) f(13) f(14) f(15) f(16) f(17) f(18) f(19) f(20) f(21) f(22) f(23) f(24) f(25) f(26) f(27) f(28) f(29) f(30) f(31) f(32) f(33) f(34) f(35) f(36) f(37) f(38) f(39) f(40) f(41) f(42) f(43) f(44) f(45) f(46) f(47) f(48) f(49) f(50) f(51) f(52) f(53) f(54) f(55) f(56) f(57) f(58) f(59) f(60) f(61) f(62) f(63) return 64; } int count4(uint64 num) { int n = 0; while(num) { num &= (num-1); n++; } return n; } ///====================================================== int count5(uint64 num, int bitSize); int count5(uint64 num) { return count5(num, sizeof(num) * 8); } int count5(uint64 num, int bitSize) { if(bitSize == 1) { return num; } else { int shiftLen = bitSize >> 1; // 移位数 int numR = num >> shiftLen; // 取高shiftLen位数字 int numL = num & (0xffffffffffffffff >> (sizeof(num) * 8-shiftLen));// 取低shiftLen位数字 return count5(numR, shiftLen) + count5( numL, shiftLen);// 合并 } } ///====================================================== const uint64 m1 = 0x5555555555555555; //binary: 0101... const uint64 m2 = 0x3333333333333333; //binary: 00110011.. const uint64 m4 = 0x0f0f0f0f0f0f0f0f; //binary: 4 zeros, 4 ones ... const uint64 m8 = 0x00ff00ff00ff00ff; //binary: 8 zeros, 8 ones ... const uint64 m16 = 0x0000ffff0000ffff; //binary: 16 zeros, 16 ones ... const uint64 m32 = 0x00000000ffffffff; //binary: 32 zeros, 32 ones ... const uint64 hff = 0xffffffffffffffff; //binary: all ones const uint64 h01 = 0x0101010101010101; //the sum of 256 to the power of 0,1,2,3... int count6(uint64 x) { x = (x & m1 ) + ((x >> 1) & m1 ); //put count of each 2 bits into those 2 bits x = (x & m2 ) + ((x >> 2) & m2 ); //put count of each 4 bits into those 4 bits x = (x & m4 ) + ((x >> 4) & m4 ); //put count of each 8 bits into those 8 bits x = (x & m8 ) + ((x >> 8) & m8 ); //put count of each 16 bits into those 16 bits x = (x & m16) + ((x >> 16) & m16); //put count of each 32 bits into those 32 bits x = (x & m32) + ((x >> 32) & m32); //put count of each 64 bits into those 64 bits return x; } //This uses fewer arithmetic operations than any other known //implementation on machines with slow multiplication. //It uses 17 arithmetic operations. int count7(uint64 x) { x -= (x >> 1) & m1; //put count of each 2 bits into those 2 bits x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits x = (x + (x >> 4)) & m4; //put count of each 8 bits into those 8 bits x += x >> 8; //put count of each 16 bits into their lowest 8 bits x += x >> 16; //put count of each 32 bits into their lowest 8 bits x += x >> 32; //put count of each 64 bits into their lowest 8 bits return x &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 count8(uint64 x) { x -= (x >> 1) & m1; //put count of each 2 bits into those 2 bits x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits x = (x + (x >> 4)) & m4; //put count of each 8 bits into those 8 bits return (x * h01)>>56; //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... } int main() { cout << count1(27834) << endl; cout << count2(27834) << endl; cout << count3(27834) << endl; cout << count4(27834) << endl; cout << count5(27834) << endl; cout << count6(27834) << endl; cout << count7(27834) << endl; cout << count8(27834) << endl; cin.get(); }
源代码下载：http://download.csdn.net/detail/csulennon/8362453
本文参考了:
1、http://www.xuebuyuan.com/2039902.html
2、http://zh.wikipedia.org/wiki/%E6%B1%89%E6%98%8E%E9%87%8D%E9%87%8F
3、http://www.cnblogs.com/xianghang123/archive/2011/08/24/2152408.html
