十種常見的排序算法

1.常見算法分類

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

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

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

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

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

---

2.算法描述與實現

2.1交換類排序

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

2.1.1冒泡排序

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

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

穩定性：穩定排序。

時間復雜度： O(n)至O(n2)(function () {。

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

最壞的情況：如果待排序數據序列為逆序，則冒泡排序需要n-1次趟起泡，每趟進行n-i次排序碼的比較和移動，即比較和移動次數均達到最大值：
比較次數:Cmax=∑i=1n−1(n−i)=n(n−1)/2=O(n2) (this).addClass(′has−numbering′).parent().append(
移動次數等於比較次數，因此最壞時間復雜度為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（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）。

最好情況：當待排序記錄已經有序，這時需要比較的次數是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分組排序，文件叫接近於有序狀態，所以新的一趟排序過程較快。因此Shell排序在效率上比直接插入排序有較大的改進。

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

穩定性：不穩定排序。

時間復雜度：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)。

示例代碼：

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。如第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)。

具體的實現見本人的另一篇blog：二路歸並排序簡介及其並行化。

---

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) 為第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);
         }
 }  
    
    
   
  
  
          
    
    
   
  
  
          

     
     
    
   
   
           
    
    
   
  
  
          
    
    
   
  
  
          

---

參考文獻

[1]計數排序、桶排序和基數排序.http://blog.csdn.net/quietwave/article/details/8008572
[2] 白話經典算法系列之六 快速排序 快速搞定.http://blog.csdn.net/morewindows/article/details/6684558
[3]白話經典算法系列之七 堆與堆排序.http://blog.csdn.net/morewindows/article/details/6709644
[4]算法與數據結構——C語言描述（第二版）.張乃孝
[5]計數排序.百度百科

('pre.prettyprint code').each(function () { var lines = (this).text().split(′\n′).length;var numbering = $('

').addClass('pre-numbering').hide(); numbering); for (i = 1; i