1.常見演算法分類

十種常見排序演算法一般分為以下幾種： 
（1）非線性時間比較類排序：交換類排序（快速排序和氣泡排序）、插入類排序（簡單插入排序和希爾排序）、選擇類排序（簡單選擇排序和堆排序）、歸併排序（二路歸併排序和多路歸併排序）；

（2）線性時間非比較類排序：計數排序、基數排序和桶排序。

總結： 
（1）在比較類排序中，歸併排序號稱最快，其次是快速排序和堆排序，兩者不相伯仲，但是有一點需要注意，資料初始排序狀態對堆排序不會產生太大的影響，而快速排序卻恰恰相反。

（2）線性時間非比較類排序一般要優於非線性時間比較類排序，但前者對待排序元素的要求較為嚴格，比如計數排序要求待排序數的最大值不能太大，桶排序要求元素按照hash分桶後桶內元素的數量要均勻。線性時間非比較類排序的典型特點是以空間換時間。

注：本博文的示例程式碼均已遞增排序為目的。

2.演算法描述與實現

2.1交換類排序

交換排序的基本方法是：兩兩比較待排序記錄的排序碼，交換不滿足順序要求的偶對，直到全部滿足位置。常見的氣泡排序和快速排序就屬於交換類排序。

2.1.1氣泡排序

演算法思想： 
從陣列中第一個數開始，依次遍歷陣列中的每一個數，通過相鄰比較交換，每一輪迴圈下來找出剩餘未排序數的中的最大數並”冒泡”至數列的頂端。

演算法步驟： 
（1）從陣列中第一個數開始，依次與下一個數比較並次交換比自己小的數，直到最後一個數。如果發生交換，則繼續下面的步驟，如果未發生交換，則陣列有序，排序結束，此時時間複雜度為O(n)； 
（2）每一輪”冒泡”結束後，最大的數將出現在亂序數列的最後一位。重複步驟（1）。

穩定性：穩定排序。

時間複雜度： O(n)至O(n2)，平均時間複雜度為O(n2)。

最好的情況：如果待排序資料序列為正序，則一趟冒泡就可完成排序，排序碼的比較次數為n-1次，且沒有移動，時間複雜度為O(n)。

最壞的情況：如果待排序資料序列為逆序，則氣泡排序需要n-1次趟起泡，每趟進行n-i次排序碼的比較和移動，即比較和移動次數均達到最大值： 
比較次數:Cmax=∑i=1n−1(n−i)=n(n−1)/2=O(n2) 
移動次數等於比較次數，因此最壞時間複雜度為O(n2)。

示例程式碼：

void bubbleSort(int array[],int len){
    //迴圈的次數為陣列長度減一，剩下的一個數不需要排序
 

    for(int i=0;i<len-1;++i){
        bool noswap=true;
        //迴圈次數為待排序數第一位數冒泡至最高位的比較次數
        for(int j=0;j<len-i-1;++j){
            if(array[j]>array[j+1]){
                array[j]=array[j]+array[j+1];
                array[j+1]=array[j]-array[j+1];
                array[j]=array[j]-array[j+1];
                //交換或者使用如下方式
                //a=a^b;
                //b=b^a;
                //a=a^b;
                noswap=false;
            }
        }
        if(noswap) break;
    }
}

2.1.2快速排序

氣泡排序是在相鄰的兩個記錄進行比較和交換，每次交換隻能上移或下移一個位置，導致總的比較與移動次數較多。快速排序又稱分割槽交換排序，是對氣泡排序的改進，快速排序採用的思想是分治思想。。

演算法原理： 
(1)從待排序的n個記錄中任意選取一個記錄（通常選取第一個記錄）為分割槽標準;

(2)把所有小於該排序列的記錄移動到左邊，把所有大於該排序碼的記錄移動到右邊，中間放所選記錄，稱之為第一趟排序；

(3)然後對前後兩個子序列分別重複上述過程，直到所有記錄都排好序。

穩定性：不穩定排序。

時間複雜度： O（nlog2n）至O(n2)，平均時間複雜度為O（nlgn）。

最好的情況：是每趟排序結束後，每次劃分使兩個子檔案的長度大致相等，時間複雜度為O（nlog2n）。

最壞的情況：是待排序記錄已經排好序，第一趟經過n-1次比較後第一個記錄保持位置不變，並得到一個n-1個元素的子記錄；第二趟經過n-2次比較，將第二個記錄定位在原來的位置上，並得到一個包括n-2個記錄的子檔案，依次類推，這樣總的比較次數是： 

Cmax=∑i=1n−1(n−i)=n(n−1)/2=O(n2)

示例程式碼：

//a：待排序陣列，low：最低位的下標，high：最高位的下標
void quickSort(int a[],int low, int high)
{
    if(low>=high)
    {
        return;
    }
    int left=low;
    int right=high;
    int key=a[left];    /*用陣列的第一個記錄作為分割槽元素*/
    while(left!=right){
        while(left<right&&a[right]>=key)    /*從右向左掃描，找第一個碼值小於key的記錄，並交換到key*/
            --right;
        a[left]=a[right];
        while(left<right&&a[left]<=key)
            ++left;
        a[right]=a[left];    /*從左向右掃描，找第一個碼值大於key的記錄，並交換到右邊*/
    }
    a[left]=key;    /*分割槽元素放到正確位置*/
    quickSort(a,low,left-1);
    quickSort(a,left+1,high);
}

2.2插入類排序

插入排序的基本方法是：每步將一個待排序的記錄，按其排序碼大小，插到前面已經排序的檔案中的適當位置，直到全部插入完為止。

2.2.1直接插入排序

原理：從待排序的n個記錄中的第二個記錄開始，依次與前面的記錄比較並尋找插入的位置，每次外迴圈結束後，將當前的數插入到合適的位置。

穩定性：穩定排序。

時間複雜度： O(n)至O（n2），平均時間複雜度是O（n2）。

最好情況：當待排序記錄已經有序，這時需要比較的次數是Cmin=n−1=O(n)。

最壞情況：如果待排序記錄為逆序，則最多的比較次數為Cmax=∑i=1n−1(i)=n(n−1)2=O(n2)。

示例程式碼：

//A：輸入陣列，len:陣列長度
void insertSort(int A[],int len)
{
    int temp;
    for(int i=1;i<len;i++)
    {
      int j=i-1;
      temp=A[i]; 
      //查詢到要插入的位置
      while(j>=0&&A[j]>temp)
      {
          A[j+1]=A[j];
          j--;
      }
      if(j!=i-1)
        A[j+1]=temp;
    }
}

2.2.2 Shell排序

Shell 排序又稱縮小增量排序, 由D. L. Shell在1959年提出，是對直接插入排序的改進。

原理： Shell排序法是對相鄰指定距離(稱為增量)的元素進行比較，並不斷把增量縮小至1，完成排序。

Shell排序開始時增量較大，分組較多，每組的記錄數目較少，故在各組內採用直接插入排序較快，後來增量di逐漸縮小，分組數減少，各組的記錄數增多，但由於已經按di−1分組排序，檔案叫接近於有序狀態，所以新的一趟排序過程較快。因此Shell排序在效率上比直接插入排序有較大的改進。

在直接插入排序的基礎上，將直接插入排序中的1全部改變成增量d即可，因為Shell排序最後一輪的增量d就為1。

穩定性：不穩定排序。

時間複雜度：O(n1.3)到O(n2)。Shell排序演算法的時間複雜度分析比較複雜，實際所需的時間取決於各次排序時增量的個數和增量的取值。研究證明，若增量的取值比較合理，Shell排序演算法的時間複雜度約為O(n1.3)。

對於增量的選擇，Shell 最初建議增量選擇為n/2，並且對增量取半直到 1；D. Knuth教授建議di+1=⌊di−13⌋序列。

//A：輸入陣列，len:陣列長度，d:初始增量(分組數)
void shellSort(int A[],int len, int d)
{
    for(int inc=d;inc>0;inc/=2){        //迴圈的次數為增量縮小至1的次數
        for(int i=inc;i<len;++i){       //迴圈的次數為第一個分組的第二個元素到陣列的結束
            int j=i-inc;
            int temp=A[i];
            while(j>=0&&A[j]>temp)
            {
                A[j+inc]=A[j];
                j=j-inc;
            }
            if((j+inc)!=i)//防止自我插入
                A[j+inc]=temp;//插入記錄
        }
    }
}

注意：從程式碼中可以看出，增量每次變化取前一次增量的一般，當增量d等於1時，shell排序就退化成了直接插入排序了。

2.3選擇類排序

選擇類排序的基本方法是：每步從待排序記錄中選出排序碼最小的記錄，順序放在已排序的記錄序列的後面，知道全部排完。

2.3.1簡單選擇排序（又稱直接選擇排序）

原理：從所有記錄中選出最小的一個數據元素與第一個位置的記錄交換；然後在剩下的記錄當中再找最小的與第二個位置的記錄交換，迴圈到只剩下最後一個數據元素為止。

穩定性：不穩定排序。

時間複雜度： 最壞、最好和平均複雜度均為O(n2)，因此，簡單選擇排序也是常見排序演算法中效能最差的排序演算法。簡單選擇排序的比較次數與檔案的初始狀態沒有關係，在第i趟排序中選出最小排序碼的記錄，需要做n-i次比較，因此總的比較次數是：∑i=1n−1(n−i)=n(n−1)/2=O(n2)。

示例程式碼：

void selectSort(int A[],int len)
{
    int i,j,k;
    for(i=0;i<len;i++){
       k=i;
       for(j=i+1;j<len;j++){
           if(A[j]<A[k])
               k=j;
       }
       if(i!=k){
           A[i]=A[i]+A[k];
           A[k]=A[i]-A[k];
           A[i]=A[i]-A[k];
       }
    }
}

2.3.2堆排序

直接選擇排序中，第一次選擇經過了n-1次比較，只是從排序碼序列中選出了一個最小的排序碼，而沒有儲存其他中間比較結果。所以後一趟排序時又要重複許多比較操作，降低了效率。J. Willioms和Floyd在1964年提出了堆排序方法，避免這一缺點。

堆的性質： 
（1）性質：完全二叉樹或者是近似完全二叉樹； 
（2）分類：大頂堆：父節點不小於子節點鍵值，小頂堆：父節點不大於子節點鍵值；圖展示一個最小堆： 

（3）左右孩子：沒有大小的順序。

（4）堆的儲存 
一般都用陣列來儲存堆，i結點的父結點下標就為(i–1)/2。它的左右子結點下標分別為 2∗i+1 和 2∗i+2。如第0個結點左右子結點下標分別為1和2。 

（5）堆的操作 
建立： 
以最小堆為例，如果以陣列儲存元素時，一個數組具有對應的樹表示形式，但樹並不滿足堆的條件，需要重新排列元素，可以建立“堆化”的樹。

插入： 
將一個新元素插入到表尾，即陣列末尾時，如果新構成的二叉樹不滿足堆的性質，需要重新排列元素，下圖演示了插入15時，堆的調整。

刪除： 
堆排序中，刪除一個元素總是發生在堆頂，因為堆頂的元素是最小的（小頂堆中）。表中最後一個元素用來填補空缺位置，結果樹被更新以滿足堆條件。

穩定性：不穩定排序。

插入程式碼實現： 
每次插入都是將新資料放在陣列最後。可以發現從這個新資料的父結點到根結點必然為一個有序的數列，現在的任務是將這個新資料插入到這個有序資料中，這就類似於直接插入排序中將一個數據併入到有序區間中，這是節點“上浮”調整。不難寫出插入一個新資料時堆的調整程式碼：

//新加入i結點,其父結點為(i-1)/2
//引數：a：陣列，i：新插入元素在陣列中的下標  
void minHeapFixUp(int a[], int i)  
{  
    int j, temp;  
    temp = a[i];  
    j = (i-1)/2;      //父結點  
    while (j >= 0 && i != 0)  
    {  
        if (a[j] <= temp)//如果父節點不大於新插入的元素，停止尋找  
            break;  
        a[i]=a[j];     //把較大的子結點往下移動,替換它的子結點  
        i = j;  
        j = (i-1)/2;  
    }  
    a[i] = temp;  
}  

因此，插入資料到最小堆時：

//在最小堆中加入新的資料data  
//a：陣列，index：插入的下標，
void minHeapAddNumber(int a[], int index, int data)  
{  
    a[index] = data;  
    minHeapFixUp(a, index);  
} 

刪除程式碼實現： 
按定義，堆中每次都只能刪除第0個數據。為了便於重建堆，實際的操作是將陣列最後一個數據與根結點，然後再從根結點開始進行一次從上向下的調整。

調整時先在左右兒子結點中找最小的，如果父結點不大於這個最小的子結點說明不需要調整了，反之將最小的子節點換到父結點的位置。此時父節點實際上並不需要換到最小子節點的位置，因為這不是父節點的最終位置。但邏輯上父節點替換了最小的子節點，然後再考慮父節點對後面的結點的影響。相當於從根結點將一個數據的“下沉”過程。下面給出程式碼：

//a為陣列，從index節點開始調整,len為節點總數 從0開始計算index節點的子節點為 2*index+1, 2*index+2,len/2-1為最後一個非葉子節點  
void minHeapFixDown(int a[],int len,int index){
    if(index>(len/2-1))//index為葉子節點不用調整
        return;
    int tmp=a[index];
    int lastIndex=index;
    while(index<=(len/2-1)){ //當下沉到葉子節點時，就不用調整了
        if(a[2*index+1]<tmp) //如果左子節點大於該節點
            lastIndex = 2*index+1;
        //如果存在右子節點且大於左子節點和該節點
        if(2*index+2<len && a[2*index+2]<a[2*index+1]&& a[2*index+2]<tmp)
            lastIndex = 2*index+2;
        if(lastIndex!=index){  //如果左右子節點有一個小於該節點則設定該節點的下沉位置
            a[index]=a[lastIndex];
            index=lastIndex;
        }else break;  //否則該節點不用下沉調整
    }
    a[lastIndex]=tmp;//將該節點放到最後的位置
}

根據思想，可以有不同版本的程式碼實現，以上是和孫凜同學一起討論出的一個版本，在這裡感謝他的參與，讀者可另行給出。個人體會，這裡建議大家根據對堆調整的過程的理解，寫出自己的程式碼，切勿看示例程式碼去理解演算法，而是理解演算法思想寫出程式碼，否則很快就會忘記。

建堆： 
有了堆的插入和刪除後，再考慮下如何對一個數據進行堆化操作。要一個一個的從陣列中取出資料來建立堆吧，不用！先看一個數組，如下圖：

很明顯，對葉子結點來說，可以認為它已經是一個合法的堆了即20，60， 65， 4， 49都分別是一個合法的堆。只要從A[4]=50開始向下調整就可以了。然後再取A[3]=30，A[2] = 17，A[1] = 12，A[0] = 9分別作一次向下調整操作就可以了。下圖展示了這些步驟：

寫出堆化陣列的程式碼：

//建立最小堆
//a:陣列，n：陣列長度
void makeMinHeap(int a[], int n)  
{  
    for (int i = n/2-1; i >= 0; i--)  
        minHeapFixDown(a, i, n);  
}  

（6）堆排序的實現 
由於堆也是用陣列來儲存的，故對陣列進行堆化後，第一次將A[0]與A[n - 1]交換，再對A[0…n-2]重新恢復堆。第二次將A[0]與A[n – 2]交換，再對A[0…n - 3]重新恢復堆，重複這樣的操作直到A[0]與A[1]交換。由於每次都是將最小的資料併入到後面的有序區間，故操作完成後整個陣列就有序了。有點類似於直接選擇排序。

因此，完成堆排序並沒有用到前面說明的插入操作，只用到了建堆和節點向下調整的操作，堆排序的操作如下：

//array:待排序陣列，len：陣列長度
void heapSort(int array[],int len){
    //建堆
    makeMinHeap(array, len); 
    //根節點和最後一個葉子節點交換，並進行堆調整，交換的次數為len-1次
    for(int i=0;i<len-1;++i){
        //根節點和最後一個葉子節點交換
        array[0] += array[len-i-1];  
        array[len-i-1] = array[0]-array[len-i-1];  
        array[0] = array[0]-array[len-i-1];

        //堆調整
        minHeapFixDown(array, 0, len-i-1);  
    }
}  

（7）堆排序的效能分析 

由於每次重新恢復堆的時間複雜度為O(logN)，共N - 1次堆調整操作，再加上前面建立堆時N / 2次向下調整，每次調整時間複雜度也為O(logN)。兩次次操作時間相加還是O(N * logN)。故堆排序的時間複雜度為O(N * logN)。

最壞情況：如果待排序陣列是有序的，仍然需要O(N * logN)複雜度的比較操作，只是少了移動的操作；

最好情況：如果待排序陣列是逆序的，不僅需要O(N * logN)複雜度的比較操作，而且需要O(N * logN)複雜度的交換操作。總的時間複雜度還是O(N * logN)。

因此，堆排序和快速排序在效率上是差不多的，但是堆排序一般優於快速排序的重要一點是，資料的初始分佈情況對堆排序的效率沒有大的影響。

2.4歸併排序

演算法思想： 
歸併排序屬於比較類非線性時間排序，號稱比較類排序中效能最佳者，在資料中應用中較廣。

歸併排序是分治法（Divide and Conquer）的一個典型的應用。將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱為二路歸併。

穩定性：穩定排序演算法；

時間複雜度: 最壞，最好和平均時間複雜度都是Θ(nlgn)。

2.5線性時間非比較類排序

2.5.1計數排序

計數排序是一個非基於比較的排序演算法，該演算法於1954年由 Harold H. Seward 提出，它的優勢在於在對於較小範圍內的整數排序。它的複雜度為Ο(n+k)（其中k是待排序數的範圍），快於任何比較排序演算法，缺點就是非常消耗空間。很明顯，如果而且當O(k)>O(n*log(n))的時候其效率反而不如基於比較的排序，比如堆排序和歸併排序和快速排序。

演算法原理： 
基本思想是對於給定的輸入序列中的每一個元素x，確定該序列中值小於x的元素的個數。一旦有了這個資訊，就可以將x直接存放到最終的輸出序列的正確位置上。例如，如果輸入序列中只有17個元素的值小於x的值，則x可以直接存放在輸出序列的第18個位置上。當然，如果有多個元素具有相同的值時，我們不能將這些元素放在輸出序列的同一個位置上，在程式碼中作適當的修改即可。

演算法步驟： 
（1）找出待排序的陣列中最大的元素； 
（2）統計陣列中每個值為i的元素出現的次數，存入陣列C的第i項； 
（3）對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）； 
（4）反向填充目標陣列：將每個元素i放在新陣列的第C(i)項，每放一個元素就將C(i)減去1。

時間複雜度：Ο(n+k)。

空間複雜度：Ο(k)。

要求：待排序數中最大數值不能太大。

穩定性：穩定。

程式碼示例：

#define MAXNUM 20    //待排序數的最大個數
#define MAX    100   //待排序數的最大值
int sorted_arr[MAXNUM]={0};

//計算排序
//arr:待排序陣列，sorted_arr：排好序的陣列，n：待排序陣列長度
void countSort(int *arr, int *sorted_arr, int n)  
{   
    int i;   
    int *count_arr = (int *)malloc(sizeof(int) * (MAX+1));  

    //初始化計數陣列   
    memset(count_arr,0,sizeof(int) * (MAX+1));

    //統計i的次數   
    for(i = 0;i<n;i++)  
        count_arr[arr[i]]++;  
    //對所有的計數累加，作用是統計arr陣列值和小於小於arr陣列值出現的個數
    for(i = 1; i<=MAX; i++)  
        count_arr[i] += count_arr[i-1];   
    //逆向遍歷源陣列（保證穩定性），根據計數陣列中對應的值填充到新的陣列中   
    for(i = n-1; i>=0; i--)  
    {  
        //count_arr[arr[i]]表示arr陣列中包括arr[i]和小於arr[i]的總數
        sorted_arr[count_arr[arr[i]]-1] = arr[i];  

        //如果arr陣列中有相同的數，arr[i]的下標減一
        count_arr[arr[i]]--;    
    }
    free(count_arr);
}

注意：計數排序是典型的以空間換時間的排序演算法，對待排序的資料有嚴格的要求，比如待排序的數值中包含負數，最大值都有限制，請謹慎使用。

2.5.2基數排序

基數排序屬於“分配式排序”（distribution sort），是非比較類線性時間排序的一種，又稱“桶子法”（bucket sort）。顧名思義，它是透過鍵值的部分資訊，將要排序的元素分配至某些“桶”中，藉以達到排序的作用。

具體描述即程式碼示例見本人另一篇blog:基數排序簡介及其並行化。

2.5.3桶排序

桶排序也是分配排序的一種，但其是基於比較排序的，這也是與基數排序最大的區別所在。

思想：桶排序演算法想法類似於散列表。首先要假設待排序的元素輸入符合某種均勻分佈，例如資料均勻分佈在[ 0,1）區間上，則可將此區間劃分為10個小區間，稱為桶，對散佈到同一個桶中的元素再排序。

要求：待排序數長度一致。

排序過程： 
（1）設定一個定量的陣列當作空桶子； 
（2）尋訪序列，並且把記錄一個一個放到對應的桶子去； 
（3）對每個不是空的桶子進行排序。 
（4）從不是空的桶子裡把專案再放回原來的序列中。

例如待排序列K= {49、 38 、 35、 97 、 76、 73 、 27、 49 }。這些資料全部在1—100之間。因此我們定製10個桶，然後確定對映函式f(k)=k/10。則第一個關鍵字49將定位到第4個桶中(49/10=4)。依次將所有關鍵字全部堆入桶中，並在每個非空的桶中進行快速排序。

時間複雜度： 
對N個關鍵字進行桶排序的時間複雜度分為兩個部分： 
(1) 迴圈計算每個關鍵字的桶對映函式，這個時間複雜度是O(N)。

(2) 利用先進的比較排序演算法對每個桶內的所有資料進行排序，對於N個待排資料，M個桶，平均每個桶[N/M]個數據，則桶內排序的時間複雜度為 ∑i=1MO(Ni∗logNi)=O(N∗logNM) 。其中Ni 為第i個桶的資料量。

因此，平均時間複雜度為線性的O(N+C)，C為桶內排序所花費的時間。當每個桶只有一個數，則最好的時間複雜度為：O(N)。

示例程式碼：

typedef struct node
 { 
     int keyNum;//桶中數的數量
     int key;   //儲存的元素
     struct node * next;  
 }KeyNode;    

 //keys待排序陣列，size陣列長度，bucket_size桶的數量
 void inc_sort(int keys[],int size,int bucket_size)
 { 
     KeyNode* k=(KeyNode *)malloc(sizeof(KeyNode)); //用於控制列印
     int i,j,b;
     KeyNode **bucket_table=(KeyNode **)malloc(bucket_size*sizeof(KeyNode *)); 
     for(i=0;i<bucket_size;i++)
     {  
         bucket_table[i]=(KeyNode *)malloc(sizeof(KeyNode)); 
         bucket_table[i]->keyNum=0;//記錄當前桶中是否有資料
         bucket_table[i]->key=0;   //記錄當前桶中的資料  
         bucket_table[i]->next=NULL; 
     }    

     for(j=0;j<size;j++)
     {   
         int index;
         KeyNode *p;
         KeyNode *node=(KeyNode *)malloc(sizeof(KeyNode));   
         node->key=keys[j];  
         node->next=NULL;  

         index=keys[j]/10;        //對映函式計算桶號  
         p=bucket_table[index];   //初始化P成為桶中資料鏈表的頭指標  
         if(p->keyNum==0)//該桶中還沒有資料 
         {    
             bucket_table[index]->next=node;    
             (bucket_table[index]->keyNum)++;  //桶的頭結點記錄桶內元素各數，此處加一
         }
         else//該桶中已有資料 
         {   
             //連結串列結構的插入排序 
             while(p->next!=NULL&&p->next->key<=node->key)   
                 p=p->next;    
             node->next=p->next;     
             p->next=node;      
             (bucket_table[index]->keyNum)++;   
         }
     }
     //列印結果
     for(b=0;b<bucket_size;b++)   
         //判斷條件是跳過桶的頭結點，桶的下個節點為元素節點不為空
         for(k=bucket_table[b];k->next!=NULL;k=k->next)  
         {
             printf("%d ",k->next->key);
         }
 }