排序總歸來說可分為兩大類，比較排序與非比較排序。比較排序就是我們常用到的氣泡排序，插入排序，希爾排序，選擇排序，堆排序，快速排序，歸併排序。非比較排序不常用，但是在對一些特殊的情況進行處理時，它的速度反而更快。

1、計數排序  

排序原理：利用雜湊的方法，將每個資料出現的次數都統計下來。雜湊表是順序的，所以我們統計完後直接遍歷雜湊表，將資料再重寫回原資料空間就可以完成排序。

注意事項：

①因為要建立雜湊表，計數排序只適用於對資料範圍比較集中的資料集合進行排序。範圍分散情況太浪費空間。如我有100個數，其中前99個都小於100，最後一個數位是10000，我們總不能開闢10000個數據大小的雜湊表來進行排序吧！這樣空間就太浪費了。 此時，就得考慮其他的演算法了。當然，這個例子也可能不恰當，這裡只是想讓你們直觀的理解。
②除了上面那種情況，還有一個問題，例如我有一千個數，1001~2000，此時我的雜湊表該怎麼開闢呢？ 開0~2000個？那前面1000個空間就浪費了！直接從1001開始開闢？你想多了！所以這種情況我們就需要遍歷一遍資料，找出最大值與最小值，求出資料範圍。範圍 = 最大值 - 最小值+1。 例如，2000-1001+1 = 1000，這樣我們就開闢0~1000個空間，用1代表1001,1000代表2000。節省了大量的空間。

③肯定有同學想到用點陣圖（BitMap）來做，但是點陣圖（BitMap）有侷限性，它要求每個資料只能出現一次。演算法有些複雜，但是可以嘗試。

時間複雜度分析：綜上所述，我們總需要兩遍遍歷，第一遍統計字資料出現次數，遍歷原資料，複雜度為O(N)，第二遍遍歷雜湊表，向原空間寫資料,遍歷了範圍次（range），時間複雜度為O(range)，所以總的時間複雜度為O(N+range)。

空間複雜度分析：開闢了範圍（range）大小的輔助雜湊表，所以空間複雜度為O(range)。

下面我對一組資料進行排序做出圖解：

c++程式碼實現：

void CountSort(int *a, int n)
{
	assert(a);

	int max = a[0];
	int min = a[0];
	//選出最大數與最小數，確定雜湊表的大小
	for (int i = 0; i < n; ++i)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
		if (a[i] < min)
		{
			min = a[i];
		}
	}

	int range = max - min + 1;
	int *count = new int[range];
	memset(count, 0, sizeof(int)*range);//當初始化成0或-1的時候可以用memset，其他情況均用for迴圈
	/*for (int i = 0; i < range; ++i)
	{
		count[i] = 0;
	}*/
	for (int i = 0; i < n; ++i)
	{
		count[a[i] - min]++;
	}
	//將資料重新寫回陣列
	int j = 0;
	for (int i = 0; i < range; ++i)
	{
		
		while ((count[i]--) > 0)
		{
			a[j] = i + min;
			j++;
		}
	}
}
 

2、基數排序

基數排序是基於資料位數的一種排序演算法，什麼叫排序位數呢？個，十，百，千，萬...明白了吧！。

它有兩種演算法

①LSD--Least Significant Digit first  從低位（個位）向高位排。

②MSD-- Most Significant Digit first 從高位向低位（個位）排。

排序原理：

因為是按位進行排序，資料可能不統一，有的最大位為十位，有的最大位為百位。我們需要找到最大的位數來進行決定迴圈的次數。

LSD和MSD的兩種演算法思想一致，下面以一組資料用LSD進行排序：

在上圖中最大的位數為4位，所以我們要對個，十，百，千，四位各進行一次迴圈排序。下面以個位為例進行示範。

①我們知道無論個十百千萬哪個位，都只有10種情況，0-9，所以我們先建立一個大小為10 的雜湊表，統計出每個位各有多少資料。例如上圖資料中個位為0的出現1次，個位為1的出現2次，個位為2的出現1次，個位為3的出現2次，個位為9的出現1次。所以雜湊表建立後得：

②再得出次數之後，我們需要開闢一個輔助空間tmp，並按0~9的順序將其重新寫入輔助空間，但是怎麼寫呢？這裡我們就需要用到矩陣轉置的思想了，再開闢一個大小為10 的陣列，用來記錄每個位（0~9）上的資料重新寫入輔助空間時的起始下標。

例如：

0位有1個數據，但是0位之前再其他位，所以0位的起始下標就為0。

1位有2個數據，1位之前有個0位，並且0位有一個數據，所以1位的起始下標為1。

2位有1個數據，2位之前有兩個位（0和1），所以2位之前一共有3個數據，所以2位的起始下標就為3。

由上面刻得出，每個位的起始下標就等於每個位之前的總資料個數之和。

所以得出起始下標陣列為：

③現在起始下標得到了，我們就可以遍歷原陣列往輔助空間裡寫資料了，但是有一點要注意，每寫入一個數據，起始下標陣列相應位的起始下標就要加1。最後得：

到這裡，我們的資料還在輔助空間tmp內，我們需要將其重新寫回我們原資料空間。這樣我們一趟排序就完成了，其他十位，百位，千位的排序只要在低位排序的基礎上進行上面相似的排序即可。

時間複雜度分析：排序最大位數次，每次都要對陣列進行一次排序，所以時間複雜度為O(N*最大位數)。

空間複雜度分析：建立與原陣列同樣大小的輔助空間，再無其他空間開銷，所以空間複雜度為O(N)。

實現程式碼：

//基數排序
//LSD  先以低位排，再以高位排
//MSD  先以高位排，再以低位排
void LSDSort(int *a, int n)
{
	assert(a);
	//求出其最大位數  個 十 百 千 萬....
	int digit = 0;
	int bash = a[0];
	for (int i = 0; i < n; ++i)
	{
		while (a[i] > (pow(10,digit)))
		{
			digit++;
		}
	}
	int flag = 1;
	for (int j = 1; j <= digit; ++j)
	{
		//建立陣列統計每個位出現數據次數
		int Digit[10] = { 0 };
		for (int i = 0; i < n; ++i)
		{
			Digit[(a[i] / flag)%10]++;
		}
		 //建立陣列統計起始下標
		int BeginIndex[10] = { 0 };
		for (int i = 1; i < 10; ++i)
		{
			BeginIndex[i] = BeginIndex[i - 1] + Digit[i - 1];
		}
		//建立輔助空間
		int *tmp = new int[n];
		memset(tmp, 0, sizeof(int)*n);//初始化
		//將資料寫入輔助空間
		for (int i = 0; i < n; ++i)
		{
			int index = (a[i] / flag)%10;
			tmp[BeginIndex[index]++] = a[i];
		}
		//將資料重新寫回原空間
		for (int i = 0; i < n; ++i)
		{
			a[i] = tmp[i];
		}
		flag = flag * 10;
		delete[] tmp;
	}
}