解法一：

對於一個正整數如果是偶數，該數的二進位制數的最後一位是 0 ，反之若是奇數，則該數的二進位制數的最後一位是 1 。因此，可以考慮利用位移、判斷奇偶來實現。

1. public int bitCount(int x){  
2.     int count = 0;  
3.     while(x!=0){  
4.      if(x%2!=0){  //判斷奇偶數  
5.         count++;  
6.      }  
7.       x = x>>>1;  
8.     }  
9.     return count;  
10.  }  

解法二：

知道了位移操作同樣可以判斷奇偶，且效率高於除法操作（“ % ”求餘操作最後還是化為除法操作）那就可以用位移來代替上的求餘運算。

      因為 x & 1 的結果為 1 或 0 ，為 1 的時候 count+=1 ，為 0 的時候 count+=0

則：

     If(x&1==1){

         count++;

     }

可簡化為： count+ = x&1;

1. public int bitCount2(int x){  
2.         int count = 0;  
3.         while(x!=0){  
4.             count+ = x&1;  
5.             x = x>>>1;  
6.         }  
7.         return count;  
8.   }  

解法三：

正整數的二進位制數最高位為 0 ，負整數和二進位制數最高們為 1 ，則可利用左移、判斷正負來實現 1 的個數的計算。

1. public int bitCount3(int x){  
2.       int count = 0;  
3.       while(x!=0){  
4.          if(x<0){  
5.             count++;  
6.          }  
7.          x = x<<1;  
8.       }  
9.       return count;  
10. }  

解法四：

前面的三種解法，運算的次數為二進位制數的位數，時間複雜度仍為 O(log₂ v) ，然而我們要計算 1 的個數，若讓演算法的運算次數只與“ 1 ”的個數有關，那複雜度就能進一步降低。

思想： x & (x-1) 可以消去 x 二進位制數的最後一位 1

1. public int bitCount4( int x )  
2. {  
3.        int count = 0;  
4.        while ( x != 0 )  
5.        {  
6.          x &= x - 1;  
7.          count++;  
8.        }  
9.        return count;  

解法五：

JAVA 的 JDK 庫裡 Integer 有個 bitCount 方法，其程式碼是這樣實現的

1. private int pop(int x)  
2.  {  
3.        x = x - ((x >> 1) & 0x55555555);  
4.        x = (x & 0x33333333) + ((x >> 2) & 0x33333333);  
5.        x = (x + (x >> 4)) & 0x0F0F0F0F;  
6.        x = x + (x >> 8);  
7.        x = x + (x >> 16);  
8.        return x & 0x0000003F;  
9.    }  

==============================================================

二分法，兩兩一組相加，之後四個四個一組相加，接著八個八個，最後就得到各位之和了。

第一行是計算每兩位中的 1 的個數 , 並且用該對應的兩位來儲存這個個數 ,
如 : 01101100 -> 01011000 , 即先把前者每兩位分段 01 10 11 00 , 分別有 1 1 2 0 個 1, 用兩位二進位制數表示為 01 01 10 00, 合起來為 01011000.

第二行是計算每四位中的 1 的個數 , 並且用該對應的四位來儲存這個個數 .
如 : 01101100 經過第一行計算後得 01011000 , 然後把 01011000 每四位分段成 0101 1000 , 段內移位相加 : 前段01+01 =10 , 後段 10+00=10, 分別用四位二進位制數表示為 0010 0010, 合起來為 00100010 .
下面的各行以此類推 , 分別計算每 8 位 ,16 位 ,32 位中的 1 的個數 .
將 0x55555555, 0x33333333, 0x0f0f0f0f 寫成二進位制數的形式就容易明白了 .

解法六：

HAKMEM 演算法

1. private int pop2(int x) {  
2.        int n;     
3.        n = (x >> 1) & 033333333333;     
4.        x = x - n;    
5.        n = (n >> 1) & 033333333333;    
6.        x = x - n;     
7.        x = (x + (x >> 3)) & 030707070707;    
8.        x = x%63;   
9.        return x;    
10.      }  

首先是將二進位制各位三個一組，求出每組中 1 的個數，然後相鄰兩組歸併，得到六個一組的 1 的個數，最後很巧妙的用除 63 取餘得到了結果。

因為 2^6 = 64 ，也就是說  x_0 + x_1 * 64 + x_2 * 64 * 64 = x_0 + x_1 + x_2 (mod 63) ，這裡的等號表示同餘

參考資料：

4. gurmeet.net/puzzles/fast-bit-counting-routines/

8. http://mindprod.com/jgloss/bitcount.html