計數排序是一種非基於比較的排序演算法，其空間複雜度和時間複雜度均為O(n+k)，其中k是整數的範圍。基於比較的排序演算法時間複雜度最小是O(nlogn)的。注意：計數排序對於實數的排序是不可行的（下面會解釋）。該演算法於1954年由 Harold H. Seward 提出。

    下面根據一個示例來講解，比如現在有個待排序的整數序列A={-1, 2, 0, 4, 3, 6, 5, 8, -2, 1, 3, 0, 3,6, 5, 2}。首先我們花O(n)的時間掃描一下整個序列，可以得到max=8，min=-2。然後我們建立一個新的陣列C，長度為(max-min+1)=11。

陣列C如下所示

    陣列index為0的元素記錄的值是-2出現的次數，依次index為1的元素記錄的是-1出現的次數。

    此時我們再掃描一下陣列A，比如對於-1，我們的操作是：-1-min=-1-(-2)=1;C[1]++。對於2，我們的操作是：2-(-2)=4;C[4]++。這樣我們又花了O(n)的時間。操作結果是：

    最後我們便可以輸出目標整數序列了，具體的邏輯是遍歷陣列C，比如C[0]=1，則輸出一次min+index即(-2+0)=-2；C[1]=1，則輸出一次-1；C[2]=2，則輸出兩次0，以此類推。目標序列為：

-2, -1, 0, 0, 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 6, 8

       分析可得，我們掃描了兩次陣列A，一次陣列C，所以計數排序的時間複雜度為2(n)+n+k（掃描陣列C的時間複雜度是n+k）。空間複雜度是：n+k（n是陣列A的空間，最後輸出目標整數序列時可以直接儲存在A中；k是陣列C的空間）。故其空間複雜度和時間複雜度均為O(n+k)。

       前面說了計數排序對於實數的排序是不可行的，這是因為我們無法根據最小值和最大值來確定陣列C的長度，比如0.1和0.2之間有無限個實數。但是如果限制實數精度，依然是可行的，比如說陣列A中的數字只保留5位小數。但是這已經不是實數了，相當於整數，因為相當於給原來陣列A的所有數都乘以10^5。

具體的Java程式碼如下所示（countSort1在空間上作了一點優化，countSort2是最原版的實現，countSort1是上述描述的實現）

public class CountSortTest {

	public static void main(String[] args) {
		
		int [] A = {-1, 2, 0, 4, 3, 6, 5, 8, -2, 1, 3, 0, 3, 6, 5, 2};
		int [] B = countSort2(A);
		for(int index = 0; index < B.length; index++)
			System.out.print(B[index] + "  ");
		System.out.println();
		countSort1(A);
		for(int index = 0; index < A.length; index++)
			System.out.print(A[index] + "  ");
		
	}
	
	private static void countSort1(int [] A) {
		int min = 0, max = 0;
		int [] C = null;
		for(int index = 0; index < A.length; index++) {
			if(A[index] < min) {
				min = A[index];
				continue;
			}
			if(A[index] > max)	max = A[index];
		}
		C = new int[max - min + 1];
		for(int index = 0; index < A.length; index++) {
			C[A[index] - min]++;
		}
		int a = 0;
		for(int index = 0; index < C.length; index++) {
			for(int count = 0; count < C[index]; count++){
				A[a++] = index + min;
			}
		}
	}
	
	private static int [] countSort2(int [] A) {
		int min = 0, max = 0;
		int [] C = null;
		int [] B = new int[A.length];
		for(int index = 0; index < A.length; index++) {
			if(A[index] < min) {
				min = A[index];
				continue;
			}
			if(A[index] > max)	max = A[index];
		}
		C = new int[max - min + 1];
		for(int index = 0; index < A.length; index++) {
			C[A[index] - min]++;
		}
		for(int index = 1; index < C.length; index++){
			C[index] = C[index] + C[index - 1];
		}
		for(int index = A.length - 1; index > -1; index--) {
			B[C[A[index] - min] - 1] = A[index];
			C[A[index] - min]--;
		}
		return B;
	}
}