轉【算法之經常使用排序算法（一）】八大經常使用內部排序算法（快排、冒泡、希爾、堆排序等）

時間  2019-12-08
標籤 算法之經常使用排序算法（一） 經常 使用 內部 排序算法 冒泡 希爾 排序 欄目 應用數學 简体版
原文   原文鏈接

概述

排序有內部排序和外部排序，內部排序是數據記錄在內存中進行排序，而外部排序是因排序的數據很大，一次不能容納所有的排序記錄，在排序過程當中須要訪問外存。java

咱們這裏說說八大排序就是內部排序。git

    

    當n較大，則應採用時間複雜度爲O(nlog2n)的排序方法：快速排序、堆排序或歸併排序序。算法

   快速排序：是目前基於比較的內部排序中被認爲是最好的方法，當待排序的關鍵字是隨機分佈時，快速排序的平均時間最短；shell

 

總結：

 


 C語言實現：數組

1.插入排序—直接插入排序(Straight Insertion Sort)

基本思想:數據結構

將一個記錄插入到已排序好的有序表中，從而獲得一個新，記錄數增1的有序表。即：先將序列的第1個記錄當作是一個有序的子序列，而後從第2個記錄逐個進行插入，直至整個序列有序爲止。ide

要點：設立哨兵，做爲臨時存儲和判斷數組邊界之用。函數

直接插入排序示例：性能

 

若是遇見一個和插入元素相等的，那麼插入元素把想插入的元素放在相等元素的後面。因此，相等元素的先後順序沒有改變，從原無序序列出去的順序就是排好序後的順序，因此插入排序是穩定的。優化

算法的實現：

  1. void print(int a[], int n ,int i){  
  2.     cout<<i <<":";  
  3.     for(int j= 0; j<8; j++){  
  4.         cout<<a[j] <<" ";  
  5.     }  
  6.     cout<<endl;  
  7. }  
  8.   
  9.   
  10. void InsertSort(int a[], int n)  
  11. {  
  12.     for(int i= 1; i<n; i++){  
  13.         if(a[i] < a[i-1]){               //若第i個元素大於i-1元素，直接插入。小於的話，移動有序表後插入  
  14.             int j= i-1;   
  15.             int x = a[i];        //複製爲哨兵，即存儲待排序元素  
  16.             a[i] = a[i-1];           //前後移一個元素  
  17.             while(x < a[j]){  //查找在有序表的插入位置  
  18.                 a[j+1] = a[j];  
  19.                 j--;         //元素後移  
  20.             }  
  21.             a[j+1] = x;      //插入到正確位置  
  22.         }  
  23.         print(a,n,i);           //打印每趟排序的結果  
  24.     }  
  25.       
  26. }  
  27.   
  28. int main(){  
  29.     int a[8] = {3,1,5,7,2,4,9,6};  
  30.     InsertSort(a,8);  
  31.     print(a,8,8);  
  32. }  


效率：

時間複雜度：O（n^2）.

其餘的插入排序有二分插入排序，2-路插入排序。

 

 2. 插入排序—希爾排序（Shell`s Sort）

希爾排序是1959 年由D.L.Shell 提出來的，相對直接排序有較大的改進。希爾排序又叫縮小增量排序

基本思想：

先將整個待排序的記錄序列分割成爲若干子序列分別進行直接插入排序，待整個序列中的記錄「基本有序」時，再對全體記錄進行依次直接插入排序。

操做方法：

  1. 選擇一個增量序列t1，t2，…，tk，其中ti>tj，tk=1；
  2. 按增量序列個數k，對序列進行k 趟排序；
  3. 每趟排序，根據對應的增量ti，將待排序列分割成若干長度爲m 的子序列，分別對各子表進行直接插入排序。僅增量因子爲1 時，整個序列做爲一個表來處理，表長度即爲整個序列的長度。

希爾排序的示例：

 

算法實現：

 

咱們簡單處理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n爲要排序數的個數

即：先將要排序的一組記錄按某個增量d（n/2,n爲要排序數的個數）分紅若干組子序列，每組中記錄的下標相差d.對每組中所有元素進行直接插入排序，而後再用一個較小的增量（d/2）對它進行分組，在每組中再進行直接插入排序。繼續不斷縮小增量直至爲1，最後使用直接插入排序完成排序。

  1. void print(int a[], int n ,int i){  
  2.     cout<<i <<":";  
  3.     for(int j= 0; j<8; j++){  
  4.         cout<<a[j] <<" ";  
  5.     }  
  6.     cout<<endl;  
  7. }  
  8. /** 
  9.  * 直接插入排序的通常形式 
  10.  * 
  11.  * @param int dk 縮小增量，若是是直接插入排序，dk=1 
  12.  * 
  13.  */  
  14.   
  15. void ShellInsertSort(int a[], int n, int dk)  
  16. {  
  17.     for(int i= dk; i<n; ++i){  
  18.         if(a[i] < a[i-dk]){          //若第i個元素大於i-1元素，直接插入。小於的話，移動有序表後插入  
  19.             int j = i-dk;     
  20.             int x = a[i];           //複製爲哨兵，即存儲待排序元素  
  21.             a[i] = a[i-dk];         //首前後移一個元素  
  22.             while(x < a[j]){     //查找在有序表的插入位置  
  23.                 a[j+dk] = a[j];  
  24.                 j -= dk;             //元素後移  
  25.             }  
  26.             a[j+dk] = x;            //插入到正確位置  
  27.         }  
  28.         print(a, n,i );  
  29.     }  
  30.       
  31. }  
  32.   
  33. /** 
  34.  * 先按增量d（n/2,n爲要排序數的個數進行希爾排序 
  35.  * 
  36.  */  
  37. void shellSort(int a[], int n){  
  38.   
  39.     int dk = n/2;  
  40.     while( dk >= 1  ){  
  41.         ShellInsertSort(a, n, dk);  
  42.         dk = dk/2;  
  43.     }  
  44. }  
  45. int main(){  
  46.     int a[8] = {3,1,5,7,2,4,9,6};  
  47.     //ShellInsertSort(a,8,1); //直接插入排序  
  48.     shellSort(a,8);           //希爾插入排序  
  49.     print(a,8,8);  
  50. }  

 

 

希爾排序時效分析很難，關鍵碼的比較次數與記錄移動次數依賴於增量因子序列d的選取，特定狀況下能夠準確估算出關鍵碼的比較次數和記錄的移動次數。目前尚未人給出選取最好的 增量因子序列的方法。增量因子序列能夠有各類取法，有取奇數的，也有取質數的，但須要注意：增量因子中除1 外沒有公因子，且最後一個增量因子必須爲1。希爾排序方法是一個不穩定的排序方法。

 

3. 選擇排序—簡單選擇排序（Simple Selection Sort）

基本思想：

在要排序的一組數中，選出最小（或者最大）的一個數與第1個位置的數交換；而後在剩下的數當中再找最小（或者最大）的與第2個位置的數交換，依次類推，直到第n-1個元素（倒數第二個數）和第n個元素（最後一個數）比較爲止。

簡單選擇排序的示例：

 

操做方法：

第一趟，從n 個記錄中找出關鍵碼最小的記錄與第一個記錄交換；

第二趟，從第二個記錄開始的n-1 個記錄中再選出關鍵碼最小的記錄與第二個記錄交換；

以此類推.....

第i 趟，則從第i 個記錄開始的n-i+1 個記錄中選出關鍵碼最小的記錄與第i 個記錄交換，

直到整個序列按關鍵碼有序。


算法實現：

  1. void print(int a[], int n ,int i){  
  2.     cout<<"第"<<i+1 <<"趟 : ";  
  3.     for(int j= 0; j<8; j++){  
  4.         cout<<a[j] <<"  ";  
  5.     }  
  6.     cout<<endl;  
  7. }  
  8. /** 
  9.  * 數組的最小值 
  10.  * 
  11.  * @return int 數組的鍵值 
  12.  */  
  13. int SelectMinKey(int a[], int n, int i)  
  14. {  
  15.     int k = i;  
  16.     for(int j=i+1 ;j< n; ++j) {  
  17.         if(a[k] > a[j]) k = j;  
  18.     }  
  19.     return k;  
  20. }  
  21.   
  22. /** 
  23.  * 選擇排序 
  24.  * 
  25.  */  
  26. void selectSort(int a[], int n){  
  27.     int key, tmp;  
  28.     for(int i = 0; i< n; ++i) {  
  29.         key = SelectMinKey(a, n,i);           //選擇最小的元素  
  30.         if(key != i){  
  31.             tmp = a[i];  a[i] = a[key]; a[key] = tmp; //最小元素與第i位置元素互換  
  32.         }  
  33.         print(a,  n , i);  
  34.     }  
  35. }  
  36. int main(){  
  37.     int a[8] = {3,1,5,7,2,4,9,6};  
  38.     cout<<"初始值：";  
  39.     for(int j= 0; j<8; j++){  
  40.         cout<<a[j] <<"  ";  
  41.     }  
  42.     cout<<endl<<endl;  
  43.     selectSort(a, 8);  
  44.     print(a,8,8);  
  45. }  

 

 簡單選擇排序的改進——二元選擇排序

簡單選擇排序，每趟循環只能肯定一個元素排序後的定位。咱們能夠考慮改進爲每趟循環肯定兩個元素（當前趟最大和最小記錄）的位置,從而減小排序所需的循環次數。改進後對n個數據進行排序，最多隻需進行[n/2]趟循環便可。具體實現以下：

  1. void SelectSort(int r[],int n) {  
  2.     int i ,j , min ,max, tmp;  
  3.     for (i=1 ;i <= n/2;i++) {    
  4.         // 作不超過n/2趟選擇排序   
  5.         min = i; max = i ; //分別記錄最大和最小關鍵字記錄位置  
  6.         for (j= i+1; j<= n-i; j++) {  
  7.             if (r[j] > r[max]) {   
  8.                 max = j ; continue ;   
  9.             }    
  10.             if (r[j]< r[min]) {   
  11.                 min = j ;   
  12.             }     
  13.       }    
  14.       //該交換操做還可分狀況討論以提升效率  
  15.       tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;  
  16.       tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;   
  17.   
  18.     }   
  19. }  

 

4. 選擇排序—堆排序（Heap Sort）

堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。

基本思想：

堆的定義以下：具備n個元素的序列（k1,k2,...,kn),當且僅當知足

時稱之爲堆。由堆的定義能夠看出，堆頂元素（即第一個元素）必爲最小項（小頂堆）。
若以一維數組存儲一個堆，則堆對應一棵徹底二叉樹，且全部非葉結點的值均不大於(或不小於)其子女的值，根結點（堆頂元素）的值是最小(或最大)的。如：

（a）大頂堆序列：（96, 83,27,38,11,09)

  (b)  小頂堆序列：（12，36，24，85，47，30，53，91）

 

初始時把要排序的n個數的序列看做是一棵順序存儲的二叉樹（一維數組存儲二叉樹），調整它們的存儲序，使之成爲一個堆，將堆頂元素輸出，獲得n 個元素中最小(或最大)的元素，這時堆的根節點的數最小（或者最大）。而後對前面(n-1)個元素從新調整使之成爲堆，輸出堆頂元素，獲得n 個元素中次小(或次大)的元素。依此類推，直到只有兩個節點的堆，並對它們做交換，最後獲得有n個節點的有序序列。稱這個過程爲堆排序。

所以，實現堆排序需解決兩個問題：
1. 如何將n 個待排序的數建成堆；
2. 輸出堆頂元素後，怎樣調整剩餘n-1 個元素，使其成爲一個新堆。


首先討論第二個問題：輸出堆頂元素後，對剩餘n-1元素從新建成堆的調整過程。
調整小頂堆的方法：

1）設有m 個元素的堆，輸出堆頂元素後，剩下m-1 個元素。將堆底元素送入堆頂（（最後一個元素與堆頂進行交換），堆被破壞，其緣由僅是根結點不知足堆的性質。

2）將根結點與左、右子樹中較小元素的進行交換。

3）若與左子樹交換：若是左子樹堆被破壞，即左子樹的根結點不知足堆的性質，則重複方法 （2）.

4）若與右子樹交換，若是右子樹堆被破壞，即右子樹的根結點不知足堆的性質。則重複方法 （2）.

5）繼續對不知足堆性質的子樹進行上述交換操做，直到葉子結點，堆被建成。

稱這個自根結點到葉子結點的調整過程爲篩選。如圖：


再討論對n 個元素初始建堆的過程。
建堆方法：對初始序列建堆的過程，就是一個反覆進行篩選的過程。

1）n 個結點的徹底二叉樹，則最後一個結點是第個結點的子樹。

2）篩選從第個結點爲根的子樹開始，該子樹成爲堆。

3）以後向前依次對各結點爲根的子樹進行篩選，使之成爲堆，直到根結點。

如圖建堆初始過程：無序序列：（49，38，65，97，76，13，27，49）
                              


                              

 

 算法的實現：

從算法描述來看，堆排序須要兩個過程，一是創建堆，二是堆頂與堆的最後一個元素交換位置。因此堆排序有兩個函數組成。一是建堆的滲透函數，二是反覆調用滲透函數實現排序的函數。

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<"  ";  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8.   
  9.   
  10. /** 
  11.  * 已知H[s…m]除了H[s] 外均知足堆的定義 
  12.  * 調整H[s],使其成爲大頂堆.即將對第s個結點爲根的子樹篩選,  
  13.  * 
  14.  * @param H是待調整的堆數組 
  15.  * @param s是待調整的數組元素的位置 
  16.  * @param length是數組的長度 
  17.  * 
  18.  */  
  19. void HeapAdjust(int H[],int s, int length)  
  20. {  
  21.     int tmp  = H[s];  
  22.     int child = 2*s+1; //左孩子結點的位置。(i+1 爲當前調整結點的右孩子結點的位置)  
  23.     while (child < length) {  
  24.         if(child+1 <length && H[child]<H[child+1]) { // 若是右孩子大於左孩子(找到比當前待調整結點大的孩子結點)  
  25.             ++child ;  
  26.         }  
  27.         if(H[s]<H[child]) {  // 若是較大的子結點大於父結點  
  28.             H[s] = H[child]; // 那麼把較大的子結點往上移動，替換它的父結點  
  29.             s = child;       // 從新設置s ,即待調整的下一個結點的位置  
  30.             child = 2*s+1;  
  31.         }  else {            // 若是當前待調整結點大於它的左右孩子，則不須要調整，直接退出  
  32.              break;  
  33.         }  
  34.         H[s] = tmp;         // 當前待調整的結點放到比其大的孩子結點位置上  
  35.     }  
  36.     print(H,length);  
  37. }  
  38.   
  39.   
  40. /** 
  41.  * 初始堆進行調整 
  42.  * 將H[0..length-1]建成堆 
  43.  * 調整完以後第一個元素是序列的最小的元素 
  44.  */  
  45. void BuildingHeap(int H[], int length)  
  46. {   
  47.     //最後一個有孩子的節點的位置 i=  (length -1) / 2  
  48.     for (int i = (length -1) / 2 ; i >= 0; --i)  
  49.         HeapAdjust(H,i,length);  
  50. }  
  51. /** 
  52.  * 堆排序算法 
  53.  */  
  54. void HeapSort(int H[],int length)  
  55. {  
  56.     //初始堆  
  57.     BuildingHeap(H, length);  
  58.     //從最後一個元素開始對序列進行調整  
  59.     for (int i = length - 1; i > 0; --i)  
  60.     {  
  61.         //交換堆頂元素H[0]和堆中最後一個元素  
  62.         int temp = H[i]; H[i] = H[0]; H[0] = temp;  
  63.         //每次交換堆頂元素和堆中最後一個元素以後，都要對堆進行調整  
  64.         HeapAdjust(H,0,i);  
  65.   }  
  66. }   
  67.   
  68. int main(){  
  69.     int H[10] = {3,1,5,7,2,4,9,6,10,8};  
  70.     cout<<"初始值：";  
  71.     print(H,10);  
  72.     HeapSort(H,10);  
  73.     //selectSort(a, 8);  
  74.     cout<<"結果：";  
  75.     print(H,10);  
  76.   
  77. }  



分析:

設樹深度爲k，。從根到葉的篩選，元素比較次數至多2(k-1)次，交換記錄至多k 次。因此，在建好堆後，排序過程當中的篩選次數不超過下式： 

                                

而建堆時的比較次數不超過4n 次，所以堆排序最壞狀況下，時間複雜度也爲：O(nlogn )。

 

5. 交換排序—冒泡排序（Bubble Sort）

基本思想：

在要排序的一組數中，對當前還未排好序的範圍內的所有數，自上而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較小的往上冒。即：每當兩相鄰的數比較後發現它們的排序與排序要求相反時，就將它們互換。

冒泡排序的示例：

 

算法的實現：

 

  1. void bubbleSort(int a[], int n){  
  2.     for(int i =0 ; i< n-1; ++i) {  
  3.         for(int j = 0; j < n-i-1; ++j) {  
  4.             if(a[j] > a[j+1])  
  5.             {  
  6.                 int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;  
  7.             }  
  8.         }  
  9.     }  
  10. }  



冒泡排序算法的改進

對冒泡排序常見的改進方法是加入一標誌性變量exchange，用於標誌某一趟排序過程當中是否有數據交換，若是進行某一趟排序時並無進行數據交換，則說明數據已經按要求排列好，可當即結束排序，避免沒必要要的比較過程。本文再提供如下兩種改進算法：

1．設置一標誌性變量pos,用於記錄每趟排序中最後一次進行交換的位置。因爲pos位置以後的記錄均已交換到位,故在進行下一趟排序時只要掃描到pos位置便可。

改進後算法以下:

  1. void Bubble_1 ( int r[], int n) {  
  2.     int i= n -1;  //初始時,最後位置保持不變  
  3.     while ( i> 0) {   
  4.         int pos= 0; //每趟開始時,無記錄交換  
  5.         for (int j= 0; j< i; j++)  
  6.             if (r[j]> r[j+1]) {  
  7.                 pos= j; //記錄交換的位置   
  8.                 int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
  9.             }   
  10.         i= pos; //爲下一趟排序做準備  
  11.      }   
  12. }    

 

2．傳統冒泡排序中每一趟排序操做只能找到一個最大值或最小值,咱們考慮利用在每趟排序中進行正向和反向兩遍冒泡的方法一次能夠獲得兩個最終值(最大者和最小者) , 從而使排序趟數幾乎減小了一半。

改進後的算法實現爲:

  1. void Bubble_2 ( int r[], int n){  
  2.     int low = 0;   
  3.     int high= n -1; //設置變量的初始值  
  4.     int tmp,j;  
  5.     while (low < high) {  
  6.         for (j= low; j< high; ++j) //正向冒泡,找到最大者  
  7.             if (r[j]> r[j+1]) {  
  8.                 tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
  9.             }   
  10.         --high;                 //修改high值, 前移一位  
  11.         for ( j=high; j>low; --j) //反向冒泡,找到最小者  
  12.             if (r[j]<r[j-1]) {  
  13.                 tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;  
  14.             }  
  15.         ++low;                  //修改low值,後移一位  
  16.     }   
  17. }   

 

6. 交換排序—快速排序（Quick Sort）

基本思想：

1）選擇一個基準元素,一般選擇第一個元素或者最後一個元素,

2）經過一趟排序講待排序的記錄分割成獨立的兩部分，其中一部分記錄的元素值均比基準元素值小。另外一部分記錄的 元素值比基準值大。

3）此時基準元素在其排好序後的正確位置

4）而後分別對這兩部分記錄用一樣的方法繼續進行排序，直到整個序列有序。

快速排序的示例：

（a）一趟排序的過程：

（b）排序的全過程

算法的實現：

 遞歸實現：

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<"  ";  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8. void swap(int *a, int *b)  
  9. {  
  10.     int tmp = *a;  
  11.     *a = *b;  
  12.     *b = tmp;  
  13. }  
  14.   
  15. int partition(int a[], int low, int high)  
  16. {  
  17.     int privotKey = a[low];                             //基準元素  
  18.     while(low < high){                                   //從表的兩端交替地向中間掃描  
  19.         while(low < high  && a[high] >= privotKey) --high;  //從high 所指位置向前搜索，至多到low+1 位置。將比基準元素小的交換到低端  
  20.         swap(&a[low], &a[high]);  
  21.         while(low < high  && a[low] <= privotKey ) ++low;  
  22.         swap(&a[low], &a[high]);  
  23.     }  
  24.     print(a,10);  
  25.     return low;  
  26. }  
  27.   
  28.   
  29. void quickSort(int a[], int low, int high){  
  30.     if(low < high){  
  31.         int privotLoc = partition(a,  low,  high);  //將表一分爲二  
  32.         quickSort(a,  low,  privotLoc -1);          //遞歸對低子表遞歸排序  
  33.         quickSort(a,   privotLoc + 1, high);        //遞歸對高子表遞歸排序  
  34.     }  
  35. }  
  36.   
  37. int main(){  
  38.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
  39.     cout<<"初始值：";  
  40.     print(a,10);  
  41.     quickSort(a,0,9);  
  42.     cout<<"結果：";  
  43.     print(a,10);  
  44.   
  45. }  



分析：

快速排序是一般被認爲在同數量級（O(nlog2n)）的排序方法中平均性能最好的。但若初始序列按關鍵碼有序或基本有序時，快排序反而蛻化爲冒泡排序。爲改進之，一般以「三者取中法」來選取基準記錄，即將排序區間的兩個端點與中點三個記錄關鍵碼居中的調整爲支點記錄。快速排序是一個不穩定的排序方法。

 
快速排序的改進

在本改進算法中,只對長度大於k的子序列遞歸調用快速排序,讓原序列基本有序，而後再對整個基本有序序列用插入排序算法排序。實踐證實，改進後的算法時間複雜度有所下降，且當k取值爲 8 左右時,改進算法的性能最佳。算法思想以下：

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<"  ";  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8. void swap(int *a, int *b)  
  9. {  
  10.     int tmp = *a;  
  11.     *a = *b;  
  12.     *b = tmp;  
  13. }  
  14.   
  15. int partition(int a[], int low, int high)  
  16. {  
  17.     int privotKey = a[low];                 //基準元素  
  18.     while(low < high){                   //從表的兩端交替地向中間掃描  
  19.         while(low < high  && a[high] >= privotKey) --high; //從high 所指位置向前搜索，至多到low+1 位置。將比基準元素小的交換到低端  
  20.         swap(&a[low], &a[high]);  
  21.         while(low < high  && a[low] <= privotKey ) ++low;  
  22.         swap(&a[low], &a[high]);  
  23.     }  
  24.     print(a,10);  
  25.     return low;  
  26. }  
  27.   
  28.   
  29. void qsort_improve(int r[ ],int low,int high, int k){  
  30.     if( high -low > k ) { //長度大於k時遞歸, k爲指定的數  
  31.         int pivot = partition(r, low, high); // 調用的Partition算法保持不變  
  32.         qsort_improve(r, low, pivot - 1,k);  
  33.         qsort_improve(r, pivot + 1, high,k);  
  34.     }   
  35. }   
  36. void quickSort(int r[], int n, int k){  
  37.     qsort_improve(r,0,n,k);//先調用改進算法Qsort使之基本有序  
  38.   
  39.     //再用插入排序對基本有序序列排序  
  40.     for(int i=1; i<=n;i ++){  
  41.         int tmp = r[i];   
  42.         int j=i-1;  
  43.         while(tmp < r[j]){  
  44.             r[j+1]=r[j]; j=j-1;   
  45.         }  
  46.         r[j+1] = tmp;  
  47.     }   
  48.   
  49. }   
  50.   
  51.   
  52.   
  53. int main(){  
  54.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
  55.     cout<<"初始值：";  
  56.     print(a,10);  
  57.     quickSort(a,9,4);  
  58.     cout<<"結果：";  
  59.     print(a,10);  
  60.   
  61. }  

 

7. 歸併排序（Merge Sort）

 

基本思想：

歸併（Merge）排序法是將兩個（或兩個以上）有序表合併成一個新的有序表，即把待排序序列分爲若干個子序列，每一個子序列是有序的。而後再把有序子序列合併爲總體有序序列。

歸併排序示例：

 

 

合併方法：

設r[i…n]由兩個有序子表r[i…m]和r[m+1…n]組成，兩個子表長度分別爲n-i +一、n-m。

  1. j=m+1；k=i；i=i; //置兩個子表的起始下標及輔助數組的起始下標
  2. 若i>m 或j>n，轉⑷ //其中一個子表已合併完，比較選取結束
  3. //選取r[i]和r[j]較小的存入輔助數組rf
    若是r[i]<r[j]，rf[k]=r[i]； i++； k++； 轉⑵
    不然，rf[k]=r[j]； j++； k++； 轉⑵
  4. //將還沒有處理完的子表中元素存入rf
    若是i<=m，將r[i…m]存入rf[k…n] //前一子表非空
    若是j<=n ,  將r[j…n] 存入rf[k…n] //後一子表非空
  5. 合併結束。
  1. //將r[i…m]和r[m +1 …n]歸併到輔助數組rf[i…n]  
  2. void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  
  3. {  
  4.     int j,k;  
  5.     for(j=m+1,k=i; i<=m && j <=n ; ++k){  
  6.         if(r[j] < r[i]) rf[k] = r[j++];  
  7.         else rf[k] = r[i++];  
  8.     }  
  9.     while(i <= m)  rf[k++] = r[i++];  
  10.     while(j <= n)  rf[k++] = r[j++];  
  11. }  
 

歸併的迭代算法

 

1 個元素的表老是有序的。因此對n 個元素的待排序列，每一個元素可當作1 個有序子表。對子表兩兩合併生成n/2個子表，所得子表除最後一個子表長度可能爲1 外，其他子表長度均爲2。再進行兩兩合併，直到生成n 個元素按關鍵碼有序的表。

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<"  ";  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8. //將r[i…m]和r[m +1 …n]歸併到輔助數組rf[i…n]  
  9. void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  
  10. {  
  11.     int j,k;  
  12.     for(j=m+1,k=i; i<=m && j <=n ; ++k){  
  13.         if(r[j] < r[i]) rf[k] = r[j++];  
  14.         else rf[k] = r[i++];  
  15.     }  
  16.     while(i <= m)  rf[k++] = r[i++];  
  17.     while(j <= n)  rf[k++] = r[j++];  
  18.     print(rf,n+1);  
  19. }  
  20.   
  21. void MergeSort(ElemType *r, ElemType *rf, int lenght)  
  22. {   
  23.     int len = 1;  
  24.     ElemType *q = r ;  
  25.     ElemType *tmp ;  
  26.     while(len < lenght) {  
  27.         int s = len;  
  28.         len = 2 * s ;  
  29.         int i = 0;  
  30.         while(i+ len <lenght){  
  31.             Merge(q, rf,  i, i+ s-1, i+ len-1 ); //對等長的兩個子表合併  
  32.             i = i+ len;  
  33.         }  
  34.         if(i + s < lenght){  
  35.             Merge(q, rf,  i, i+ s -1, lenght -1); //對不等長的兩個子表合併  
  36.         }  
  37.         tmp = q; q = rf; rf = tmp; //交換q,rf，以保證下一趟歸併時，仍從q 歸併到rf  
  38.     }  
  39. }  
  40.   
  41.   
  42. int main(){  
  43.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
  44.     int b[10];  
  45.     MergeSort(a, b, 10);  
  46.     print(b,10);  
  47.     cout<<"結果：";  
  48.     print(a,10);  
  49.   
  50. }  

 

兩路歸併的遞歸算法

  1. void MSort(ElemType *r, ElemType *rf,int s, int t)  
  2. {   
  3.     ElemType *rf2;  
  4.     if(s==t) r[s] = rf[s];  
  5.     else  
  6.     {   
  7.         int m=(s+t)/2;          /*平分*p 表*/  
  8.         MSort(r, rf2, s, m);        /*遞歸地將p[s…m]歸併爲有序的p2[s…m]*/  
  9.         MSort(r, rf2, m+1, t);      /*遞歸地將p[m+1…t]歸併爲有序的p2[m+1…t]*/  
  10.         Merge(rf2, rf, s, m+1,t);   /*將p2[s…m]和p2[m+1…t]歸併到p1[s…t]*/  
  11.     }  
  12. }  
  13. void MergeSort_recursive(ElemType *r, ElemType *rf, int n)  
  14. {   /*對順序表*p 做歸併排序*/  
  15.     MSort(r, rf,0, n-1);  
  16. }  

8. 桶排序/基數排序(Radix Sort)

說基數排序以前，咱們先說桶排序：

基本思想：是將陣列分到有限數量的桶子裏。每一個桶子再個別排序（有可能再使用別的排序算法或是以遞迴方式繼續使用桶排序進行排序）。桶排序是鴿巢排序的一種概括結果。當要被排序的陣列內的數值是均勻分配的時候，桶排序使用線性時間（Θ（n））。但桶排序並非 比較排序，他不受到 O(n log n) 下限的影響。
         簡單來講，就是把數據分組，放在一個個的桶中，而後對每一個桶裏面的在進行排序。  

 

 例如要對大小爲[1..1000]範圍內的n個整數A[1..n]排序  

 首先，能夠把桶設爲大小爲10的範圍，具體而言，設集合B[1]存儲[1..10]的整數，集合B[2]存儲   (10..20]的整數，……集合B[i]存儲(   (i-1)*10,   i*10]的整數，i   =   1,2,..100。總共有  100個桶。  

  而後，對A[1..n]從頭至尾掃描一遍，把每一個A[i]放入對應的桶B[j]中。  再對這100個桶中每一個桶裏的數字排序，這時可用冒泡，選擇，乃至快排，通常來講任  何排序法均可以。

  最後，依次輸出每一個桶裏面的數字，且每一個桶中的數字從小到大輸出，這  樣就獲得全部數字排好序的一個序列了。  

  假設有n個數字，有m個桶，若是數字是平均分佈的，則每一個桶裏面平均有n/m個數字。若是  

  對每一個桶中的數字採用快速排序，那麼整個算法的複雜度是  

  O(n   +   m   *   n/m*log(n/m))   =   O(n   +   nlogn   -   nlogm)  

  從上式看出，當m接近n的時候，桶排序複雜度接近O(n)  

  固然，以上覆雜度的計算是基於輸入的n個數字是平均分佈這個假設的。這個假設是很強的  ，實際應用中效果並無這麼好。若是全部的數字都落在同一個桶中，那就退化成通常的排序了。  

        前面說的幾大排序算法 ，大部分時間複雜度都是O（n2），也有部分排序算法時間複雜度是O(nlogn)。而桶式排序卻能實現O（n）的時間複雜度。但桶排序的缺點是：

        1）首先是空間複雜度比較高，須要的額外開銷大。排序有兩個數組的空間開銷，一個存放待排序數組，一個就是所謂的桶，好比待排序值是從0到m-1，那就須要m個桶，這個桶數組就要至少m個空間。

        2）其次待排序的元素都要在必定的範圍內等等。

       桶式排序是一種分配排序。分配排序的特定是不須要進行關鍵碼的比較，但前提是要知道待排序列的一些具體狀況。

 

分配排序的基本思想：說白了就是進行屢次的桶式排序。

基數排序過程無須比較關鍵字，而是經過「分配」和「收集」過程來實現排序。它們的時間複雜度可達到線性階：O(n)。

實例:

撲克牌中52 張牌，可按花色和麪值分紅兩個字段，其大小關係爲：
花色： 梅花< 方塊< 紅心< 黑心  
面值： 2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < J < Q < K < A

若對撲克牌按花色、面值進行升序排序，獲得以下序列：


即兩張牌，若花色不一樣，不論面值怎樣，花色低的那張牌小於花色高的，只有在同花色狀況下，大小關係才由面值的大小肯定。這就是多關鍵碼排序。

爲獲得排序結果，咱們討論兩種排序方法。
方法1：先對花色排序，將其分爲4 個組，即梅花組、方塊組、紅心組、黑心組。再對每一個組分別按面值進行排序，最後，將4 個組鏈接起來便可。
方法2：先按13 個面值給出13 個編號組(2 號，3 號，...，A 號)，將牌按面值依次放入對應的編號組，分紅13 堆。再按花色給出4 個編號組(梅花、方塊、紅心、黑心)，將2號組中牌取出分別放入對應花色組，再將3 號組中牌取出分別放入對應花色組，……，這樣，4 個花色組中均按面值有序，而後，將4 個花色組依次鏈接起來便可。

設n 個元素的待排序列包含d 個關鍵碼{k1，k2，…，kd}，則稱序列對關鍵碼{k1，k2，…，kd}有序是指：對於序列中任兩個記錄r[i]和r[j](1≤i≤j≤n)都知足下列有序關係：

                                                               

其中k1 稱爲最主位關鍵碼，kd 稱爲最次位關鍵碼     。

 

兩種多關鍵碼排序方法：

多關鍵碼排序按照從最主位關鍵碼到最次位關鍵碼或從最次位到最主位關鍵碼的順序逐次排序，分兩種方法：

最高位優先(Most Significant Digit first)法，簡稱MSD 法：

1）先按k1 排序分組，將序列分紅若干子序列，同一組序列的記錄中，關鍵碼k1 相等。

2）再對各組按k2 排序分紅子組，以後，對後面的關鍵碼繼續這樣的排序分組，直到按最次位關鍵碼kd 對各子組排序後。

3）再將各組鏈接起來，便獲得一個有序序列。撲克牌按花色、面值排序中介紹的方法一便是MSD 法。

最低位優先(Least Significant Digit first)法，簡稱LSD 法：

1) 先從kd 開始排序，再對kd-1進行排序，依次重複，直到按k1排序分組分紅最小的子序列後。

2) 最後將各個子序列鏈接起來，即可獲得一個有序的序列, 撲克牌按花色、面值排序中介紹的方法二便是LSD 法。

 

基於LSD方法的鏈式基數排序的基本思想

　　「多關鍵字排序」的思想實現「單關鍵字排序」。對數字型或字符型的單關鍵字，能夠看做由多個數位或多個字符構成的多關鍵字，此時能夠採用「分配-收集」的方法進行排序，這一過程稱做基數排序法，其中每一個數字或字符可能的取值個數稱爲基數。好比，撲克牌的花色基數爲4，面值基數爲13。在整理撲克牌時，既能夠先按花色整理，也能夠先按面值整理。按花色整理時，先按紅、黑、方、花的順序分紅4摞（分配），再按此順序再疊放在一塊兒（收集），而後按面值的順序分紅13摞（分配），再按此順序疊放在一塊兒（收集），如此進行二次分配和收集便可將撲克牌排列有序。   

基數排序:

是按照低位先排序，而後收集；再按照高位排序，而後再收集；依次類推，直到最高位。有時候有些屬性是有優先級順序的，先按低優先級排序，再按高優先級排序。最後的次序就是高優先級高的在前，高優先級相同的低優先級高的在前。基數排序基於分別排序，分別收集，因此是穩定的。

算法實現：

  1. Void RadixSort(Node L[],length,maxradix)  
  2. {  
  3.    int m,n,k,lsp;  
  4.    k=1;m=1;  
  5.    int temp[10][length-1];  
  6.    Empty(temp); //清空臨時空間  
  7.    while(k<maxradix) //遍歷全部關鍵字  
  8.    {  
  9.      for(int i=0;i<length;i++) //分配過程  
  10.     {  
  11.        if(L[i]<m)  
  12.           Temp[0][n]=L[i];  
  13.        else  
  14.           Lsp=(L[i]/m)%10; //肯定關鍵字  
  15.        Temp[lsp][n]=L[i];  
  16.        n++;  
  17.    }  
  18.    CollectElement(L,Temp); //收集  
  19.    n=0;  
  20.    m=m*10;  
  21.   k++;  
  22.  }  
  23. }  



 

 

 

 

總結

各類排序的穩定性，時間複雜度和空間複雜度總結：

 咱們比較時間複雜度函數的狀況：

 

                             時間複雜度函數O(n)的增加狀況

因此對n較大的排序記錄。通常的選擇都是時間複雜度爲O(nlog2n)的排序方法。

 

時間複雜度來講：

(1)平方階(O(n2))排序
　　各種簡單排序:直接插入、直接選擇和冒泡排序；
 (2)線性對數階(O(nlog2n))排序
　　快速排序、堆排序和歸併排序；
 (3)O(n1+§))排序,§是介於0和1之間的常數。

       希爾排序
(4)線性階(O(n))排序
　　基數排序，此外還有桶、箱排序。

說明：

當原表有序或基本有序時，直接插入排序和冒泡排序將大大減小比較次數和移動記錄的次數，時間複雜度可降至O（n）；

而快速排序則相反，當原表基本有序時，將蛻化爲冒泡排序，時間複雜度提升爲O（n2）；

原表是否有序，對簡單選擇排序、堆排序、歸併排序和基數排序的時間複雜度影響不大。

 

穩定性：

排序算法的穩定性:若待排序的序列中，存在多個具備相同關鍵字的記錄，通過排序， 這些記錄的相對次序保持不變，則稱該算法是穩定的；若經排序後，記錄的相對 次序發生了改變，則稱該算法是不穩定的。 
     穩定性的好處：排序算法若是是穩定的，那麼從一個鍵上排序，而後再從另外一個鍵上排序，第一個鍵排序的結果能夠爲第二個鍵排序所用。基數排序就是這樣，先按低位排序，逐次按高位排序，低位相同的元素其順序再高位也相同時是不會改變的。另外，若是排序算法穩定，能夠避免多餘的比較；

穩定的排序算法：冒泡排序、插入排序、歸併排序和基數排序

不是穩定的排序算法：選擇排序、快速排序、希爾排序、堆排序

 

選擇排序算法準則：

每種排序算法都各有優缺點。所以，在實用時需根據不一樣狀況適當選用，甚至能夠將多種方法結合起來使用。

選擇排序算法的依據

影響排序的因素有不少，平均時間複雜度低的算法並不必定就是最優的。相反，有時平均時間複雜度高的算法可能更適合某些特殊狀況。同時，選擇算法時還得考慮它的可讀性，以利於軟件的維護。通常而言，須要考慮的因素有如下四點：

1．待排序的記錄數目n的大小；

2．記錄自己數據量的大小，也就是記錄中除關鍵字外的其餘信息量的大小；

3．關鍵字的結構及其分佈狀況；

4．對排序穩定性的要求。

設待排序元素的個數爲n.

1）當n較大，則應採用時間複雜度爲O(nlog2n)的排序方法：快速排序、堆排序或歸併排序序。

   快速排序：是目前基於比較的內部排序中被認爲是最好的方法，當待排序的關鍵字是隨機分佈時，快速排序的平均時間最短；
       堆排序 ：  若是內存空間容許且要求穩定性的，

       歸併排序：它有必定數量的數據移動，因此咱們可能過與插入排序組合，先得到必定長度的序列，而後再合併，在效率上將有所提升。

2）  當n較大，內存空間容許，且要求穩定性 =》歸併排序

3）當n較小，可採用直接插入或直接選擇排序。

    直接插入排序：當元素分佈有序，直接插入排序將大大減小比較次數和移動記錄的次數。

    直接選擇排序 ：元素分佈有序，若是不要求穩定性，選擇直接選擇排序

5）通常不使用或不直接使用傳統的冒泡排序。

6）基數排序
它是一種穩定的排序算法，但有必定的侷限性：
　　一、關鍵字可分解。
　　二、記錄的關鍵字位數較少，若是密集更好
　　三、若是是數字時，最好是無符號的，不然將增長相應的映射覆雜度，可先將其正負分開排序。

 Java實現：

 

第一：直接插入排序

 

1. 基本思想：在要排序的一組數中，假設前面(n-1) [n>=2] 個數已是排好順序的，如今要把第n個數插到前面的有序數中，使得這n個數也是排好順序的。如此反覆循環，直到所有排好順序。

2. 實例

3. 用java實現

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;    
  2.   
  3. public class InsertSort {    
  4.   
  5.     public InsertSort(){    
  6.         int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};    
  7.         int temp=0;    
  8.         for(int i=1;i<a.length;i++){    
  9.             int j=i-1;    
  10.             temp=a[i];    
  11.             for(;j>=0 && temp<a[j];j--){    
  12.                 a[j+1]=a[j];//將大於temp的值總體後移一個單位    
  13.             }    
  14.             a[j+1]=temp;    
  15.         }    
  16.   
  17.         for(int i=0;i<a.length;i++)    
  18.             System.out.println(a[i]);    
  19.     }    
  20.   
  21. }    

4. 特色：每次循環一邊以後，最前面的一部分必定是有序序列，可是位置不是最終的

 

 

第二：希爾排序（最小增量排序）

1. 基本思想：算法先將要排序的一組數按某個增量d（n/2,n爲要排序數的個數）分紅若干組，每組中記錄的下標相差d.對每組中所有元素進行直接插入排序，而後再用一個較小的增量（d/2）對它進行分組，在每組中再進行直接插入排序。當增量減到1時，進行直接插入排序後，排序完成。

2. 實例：

 

3. 用java實現

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;  
  2.   
  3. public class ShellSort {    
  4.     public ShellSort(){    
  5.         int a[]={1,54,6,3,78,34,12,45,56,100};    
  6.         double d1=a.length;    
  7.         int temp=0;    
  8.         while(true){    
  9.             d1= Math.ceil(d1/2);    
  10.             int d=(int) d1;    
  11.             for(int x=0;x<d;x++){    
  12.                 for(int i=x+d;i<a.length;i+=d){    
  13.                     int j=i-d;    
  14.                     temp=a[i];    
  15.                     for(;j>=0 && temp<a[j];j-=d){    
  16.                         a[j+d]=a[j];    
  17.                     }    
  18.                     a[j+d]=temp;    
  19.                 }    
  20.             }    
  21.             if(d==1)    
  22.                 break;    
  23.         }    
  24.         for(int i=0;i<a.length;i++)    
  25.             System.out.println(a[i]);    
  26.   
  27.     }    
  28.   
  29. }    

 

 

第三：簡單選擇排序

1. 基本思想：在要排序的一組數中，選出最小的一個數與第一個位置的數交換；而後在剩下的數當中再找最小的與第二個位置的數交換，如此循環到倒數第二數和最後一個數比較爲止。

2. 實例：

 

3. 用java實現

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;  
  2.   
  3. public class SelectSort {    
  4.   
  5.     public SelectSort(){    
  6.         int a[]={1,54,6,3,78,34,12,45};    
  7.         int position=0;    
  8.         for(int i=0;i<a.length;i++){    
  9.             int j=i+1;    
  10.             position=i;    
  11.             int temp=a[i];    
  12.             for(;j<a.length;j++){    
  13.                 if(a[j]<temp){    
  14.                     temp=a[j];    
  15.                     position=j;    
  16.                 }    
  17.             }    
  18.             a[position]=a[i];    
  19.             a[i]=temp;    
  20.         }    
  21.         for(int i=0;i<a.length;i++)    
  22.             System.out.println(a[i]);    
  23.   
  24.     }    
  25.   
  26. }    

 

4. 特色：每次循環一邊以後，最前面的一部分必定是有序的，並且這個順序不會再改變。這個和前面的插入排序有點不同。

 

第四：堆排序

1. 基本思想：堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。

堆的定義以下：具備n個元素的序列（h1,h2,...,hn),當且僅當知足（hi>=h2i,hi>=2i+1;大頂堆）或（hi<=h2i,hi<=2i+1;小頂堆）(i=1,2,...,n/2)時稱之爲堆。在這裏只討論知足前者條件的堆。由堆的定義能夠看出，堆頂元素（即第一個元素）必爲最大項（大頂堆）。徹底二叉樹能夠很直觀地表示堆的結構。堆頂爲根，其它爲左子樹、右子樹。初始時把要排序的數的序列看做是一棵順序存儲的二叉樹，調整它們的存儲序，使之成爲一個堆，這時堆的根節點的數最大。而後將根節點與堆的最後一個節點交換。而後對前面(n-1)個數從新調整使之成爲堆。依此類推，直到只有兩個節點的堆，並對它們做交換，最後獲得有n個節點的有序序列。從算法描述來看，堆排序須要兩個過程，一是創建堆，二是堆頂與堆的最後一個元素交換位置。因此堆排序有兩個函數組成。一是建堆的滲透函數，二是反覆調用滲透函數實現排序的函數。

2. 實例：

初始序列：46,79,56,38,40,84

建堆：

首先咱們將須要排序的序列按照自上往下，從左到右的順序構形成一顆徹底二叉樹，而後開始修改爲堆

說明：對初始狀態修改爲堆的形式，從葉子節點開始操做，咱們將其改變成大頂堆，遵循的原則是父節點大於其左右子節點，若是不符合規則，就將其子節點和父節點進行交換操做，操做的順序是從右向左，自下而上。固然每次操做完以後都必須遵循父節點大於其左右子節點，好比到第三個狀態了，當咱們把84移到頂部以後，發現46比56小，因此還須要進行操做。同時左子樹和右子樹也要遵循規則。下面的圖片就是最終的堆結構

那麼下面就來看一下如何選擇數：

交換，從堆中踢出最大數，就是根節點。

 

每次踢出根節點以後對於剩餘結點再建堆，這時候咱們就將最後一個葉子節點放到根節點的位置，而後再建堆，好比，當咱們踢出最大值84的時候，咱們就將最後的一個葉子節點46放到根節點中，而後按照以前的建堆的原則重新建堆。再交換踢出最大數，以下圖：

 

依次類推：最後堆中剩餘的最後兩個結點交換，踢出一個，排序完成。

3. 用java實現

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;  
  2.   
  3. import java.util.Arrays;    
  4.   
  5. public class HeapSort {    
  6.   
  7.     int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};    
  8.   
  9.     public HeapSort(){    
  10.         heapSort(a);    
  11.   
  12.     }    
  13.   
  14.     public  void heapSort(int[] a){    
  15.         System.out.println("開始排序");    
  16.         int arrayLength=a.length;    
  17.         //循環建堆    
  18.         for(int i=0;i<arrayLength-1;i++){    
  19.             //建堆    
  20.             buildMaxHeap(a,arrayLength-1-i);    
  21.             //交換堆頂和最後一個元素    
  22.             swap(a,0,arrayLength-1-i);    
  23.             System.out.println(Arrays.toString(a));    
  24.         }    
  25.     }    
  26.   
  27.     private  void swap(int[] data, int i, int j) {    
  28.         int tmp=data[i];    
  29.         data[i]=data[j];    
  30.         data[j]=tmp;    
  31.     }    
  32.   
  33.     //對data數組從0到lastIndex建大頂堆    
  34.     private void buildMaxHeap(int[] data, int lastIndex) {    
  35.         //從lastIndex處節點（最後一個節點）的父節點開始    
  36.         for(int i=(lastIndex-1)/2;i>=0;i--){    
  37.             //k保存正在判斷的節點    
  38.             int k=i;    
  39.             //若是當前k節點的子節點存在    
  40.             while(k*2+1<=lastIndex){    
  41.                 //k節點的左子節點的索引    
  42.                 int biggerIndex=2*k+1;    
  43.                 //若是biggerIndex小於lastIndex，即biggerIndex+1表明的k節點的右子節點存在    
  44.                 if(biggerIndex<lastIndex){    
  45.                     //若果右子節點的值較大    
  46.                     if(data[biggerIndex]<data[biggerIndex+1]){    
  47.                         //biggerIndex老是記錄較大子節點的索引    
  48.                         biggerIndex++;    
  49.                     }    
  50.                 }    
  51.   
  52.                 //若是k節點的值小於其較大的子節點的值    
  53.                 if(data[k]<data[biggerIndex]){    
  54.                     //交換他們    
  55.                     swap(data,k,biggerIndex);    
  56.                     //將biggerIndex賦予k，開始while循環的下一次循環，從新保證k節點的值大於其左右子節點的值    
  57.                     k=biggerIndex;    
  58.                 }else{    
  59.                     break;    
  60.                 }    
  61.   
  62.             }    
  63.   
  64.         }    
  65.   
  66.     }   
  67. }  

第五： 冒泡排序

1. 基本思想：在要排序的一組數中，對當前還未排好序的範圍內的所有數，自上而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較小的往上冒。即：每當兩相鄰的數比較後發現它們的排序與排序要求相反時，就將它們互換。

2. 實例：

3. 用java實現

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;  
  2.   
  3. public class BubbleSort {    
  4.     public BubbleSort(){    
  5.         int a[]={1,54,6,3,78,34,12,45};    
  6.         int temp=0;    
  7.         for(int i=0;i<a.length;i++){    
  8.             for(int j=i+1;j<a.length;j++){    
  9.                 if(a[i]>a[j]){    
  10.                     temp=a[i];    
  11.                     a[i]=a[j];    
  12.                     a[j]=temp;    
  13.                 }    
  14.             }    
  15.         }    
  16.         for(int i=0;i<a.length;i++)    
  17.             System.out.println(a[i]);       
  18.     }    
  19.   
  20. }    

 

通過道友的提醒，發現上面的不是正宗的冒泡排序，其實上面的至關去選擇排序的變種。因此更正過來：

正宗的冒泡排序：

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;  
  2.   
  3. public class BubbleSort {    
  4.     public BubbleSort(){    
  5.         int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};    
  6.         int temp=0;    
  7.         for(int i=0;i<a.length-1;i++){    
  8.             for(int j=0;j<a.length-1-i;j++){    
  9.                 if(a[j]>a[j+1]){    
  10.                     temp=a[j];    
  11.                     a[j]=a[j+1];    
  12.                     a[j+1]=temp;    
  13.                 }    
  14.             }    
  15.         }    
  16.         for(int i=0;i<a.length;i++)    
  17.             System.out.println(a[i]);       
  18.     }    
  19. }  

4. 特色：和選擇排序的特色同樣，每循環一邊以後最前面的一部分是有序的，並且位置不會再改變了

注：上面的冒泡排序的過程咱們是能夠進行一些優化操做的，能夠添加一個變量來記錄每次有沒有交換操做，若是沒有的話，說明序列已經有序了，不須要在進行比較了，代碼以下：

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;  
  2.   
  3. public class EnhanceBubbleSort {    
  4.     public EnhanceBubbleSort(){    
  5.         int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};   
  6.         int temp=0;   
  7.         boolean isChange = false;//記錄每次有沒有交換值的狀態  
  8.         for(int i=0;i<a.length-1;i++){    
  9.             isChange = false;  
  10.             for(int j=0;j<a.length-1-i;j++){    
  11.                 if(a[j]>a[j+1]){  
  12.                     isChange = true;  
  13.                     temp=a[j];    
  14.                     a[j]=a[j+1];    
  15.                     a[j+1]=temp;    
  16.                 }    
  17.             }   
  18.             //若是一趟下來以後沒有交換操做，說明數組已經有序了，直接跳出循環  
  19.             if(!isChange)  
  20.                 break;  
  21.         }    
  22.         for(int i=0;i<a.length;i++)    
  23.             System.out.println(a[i]);       
  24.     }   
  25. }  

若是原始序列大部分有序了，這個效率比以前的冒泡排序效果高出不少

 

 

 

第六：快速排序

1. 基本思想：選擇一個基準元素,一般選擇第一個元素或者最後一個元素,經過一趟掃描，將待排序列分紅兩部分,一部分比基準元素小,一部分大於等於基準元素,此時基準元素在其排好序後的正確位置,而後再用一樣的方法遞歸地排序劃分的兩部分。

2. 實例：

3. 用java實現

[java]  view plain copy
 
 
 
  1. package com.weijia.demo;  
  2.   
  3. public class QuickSort {    
  4.   
  5.     int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};    
  6.     public QuickSort(){    
  7.         quick(a);    
  8.         for(int i=0;i<a.length;i++)    
  9.             System.out.println(a[i]);    
  10.   
  11.     }    
  12.   
  13.     public int getMiddle(int[] list, int low, int high) {       
  14.         int tmp = list[low];    //數組的第一個做爲中軸       
  15.         while (low < high) {       
  16.             while (low < high && list[high] >= tmp) {       
  17.                 high--;       
  18.             }       
  19.             list[low] = list[high];   //比中軸小的記錄移到低端       
  20.             while (low < high && list[low] <= tmp) {       
  21.                 low++;       
  22.             }       
  23.             list[high] = list[low];   //比中軸大的記錄移到高端       
  24.         }       
  25.         list[low] = tmp;              //中軸記錄到尾       
  26.         return low;                   //返回中軸的位置       
  27.   
  28.     }      
  29.   
  30.     public void _quickSort(int[] list, int low, int high) {       
  31.         if (low < high) {       
  32.             int middle = getMiddle(list, low, high);  //將list數組進行一分爲二       
  33.             _quickSort(list, low, middle - 1);        //對低字表進行遞歸排序       
  34.             _quickSort(list, middle + 1, high);       //對高字表進行遞歸排序       
  35.         }       
  36.     }     
  37.   
  38.     public void quick(int[] a2) {       
  39.         if (a2.length > 0) {    //查看數組是否爲空       
  40.             _quickSort(a2, 0, a2.length - 1);       
  41.         }       
  42.     }     
  43.   
  44. }    

4. 特色：每一趟結束以後，中間的數的位置不會在改變了，並且每次都是以這個中間數爲中心軸的話，一部分是比這個數都小的，另一部分都是比這個數都大的

 

 

 

第七：歸併排序

1. 基本思想：歸併（Merge）排序法是將兩個（或兩個以上）有序表合併成一個新的有序表，即把待排序序列分爲若干個子序列，每一個子序列是有序的。而後再把有序子序列合併爲總體有序序列。

2. 實例：

3. 用java實現

 

[java]  view plain copy
 
 
 
  1. package com.weijia.demo;  
  2.   
  3. import java.util.Arrays;    
  4.   
  5. public class MergingSort {    
  6.       
  7.     int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};    
  8.       
  9.     public  MergingSort(){    
  10.         sort(a,0,a.length-1);    
  11.         for(int i=0;i<a.length;i++)    
  12.             System.out.println(a[i]);    
  13.     }    
  14.       
  15.     public void sort(int[] data, int left, int right) {    
  16.         if(left<right){    
  17.             //找出中間索引    
  18.             int center=(left+right)/2;    
  19.             //對左邊數組進行遞歸    
  20.             sort(data,left,center);    
  21.             //對右邊數組進行遞歸    
  22.             sort(data,center+1,right);    
  23.             //合併    
  24.             merge(data,left,center,right);    
  25.   
  26.         }    
  27.     }    
  28.       
  29.     public void merge(int[] data, int left, int center, int right) {    
  30.         int [] tmpArr=new int[data.length];    
  31.         int mid=center+1;    
  32.         //third記錄中間數組的索引    
  33.         int third=left;    
  34.         int tmp=left;    
  35.         while(left<=center&&mid<=right){    
  36.             //從兩個數組中取出最小的放入中間數組    
  37.             if(data[left]<=data[mid]){    
  38.                 tmpArr[third++]=data[left++];    
  39.             }else{    
  40.                 tmpArr[third++]=data[mid++];    
  41.             }    
  42.         }    
  43.         //剩餘部分依次放入中間數組    
  44.         while(mid<=right){    
  45.             tmpArr[third++]=data[mid++];    
  46.         }    
  47.         while(left<=center){    
  48.             tmpArr[third++]=data[left++];    
  49.         }    
  50.         //將中間數組中的內容複製回原數組    
  51.         while(tmp<=right){    
  52.             data[tmp]=tmpArr[tmp++];    
  53.         }    
  54.         System.out.println(Arrays.toString(data));    
  55.     }    
  56.   
  57. }    


 

第八：基數排序

1. 基本思想：將全部待比較數值（正整數）統一爲一樣的數位長度，數位較短的數前面補零。而後，從最低位開始，依次進行一次排序。這樣從最低位排序一直到最高位排序完成之後,數列就變成一個有序序列。
2. 實例：

3. 用java實現
[java] view plain copy
 
 
 
  1. package com.weijia.demo;  
  2.   
  3. import java.util.ArrayList;    
  4. import java.util.List;    
  5.   
  6. public class RadixSort {    
  7.   
  8.     int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,25,53,51};   
  9.       
  10.     public RadixSort(){    
  11.         sort(a);    
  12.         for(int i=0;i<a.length;i++)    
  13.             System.out.println(a[i]);    
  14.     }    
  15.   
  16.     public  void sort(int[] array){       
  17.         //首先肯定排序的趟數;       
  18.         int max=array[0];       
  19.         for(int i=1;i<array.length;i++){       
  20.             if(array[i]>max){       
  21.                 max=array[i];       
  22.             }       
  23.         }       
  24.   
  25.         int time=0;       
  26.         //判斷位數;       
  27.         while(max>0){       
  28.             max/=10;       
  29.             time++;       
  30.         }       
  31.   
  32.         //創建10個隊列;       
  33.         List<ArrayList> queue=new ArrayList<ArrayList>();       
  34.         for(int i=0;i<10;i++){       
  35.             ArrayList<Integer> queue1=new ArrayList<Integer>();     
  36.             queue.add(queue1);       
  37.         }       
  38.   
  39.         //進行time次分配和收集;       
  40.         for(int i=0;i<time;i++){       
  41.             //分配數組元素;       
  42.             for(int j=0;j<array.length;j++){       
  43.                 //獲得數字的第time+1位數;     
  44.                 int x=array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);    
  45.                 ArrayList<Integer> queue2=queue.get(x);    
  46.                 queue2.add(array[j]);    
  47.                 queue.set(x, queue2);    
  48.             }       
  49.             int count=0;//元素計數器;       
  50.             //收集隊列元素;       
  51.             for(int k=0;k<10;k++){     
  52.                 while(queue.get(k).size()>0){    
  53.                     ArrayList<Integer> queue3=queue.get(k);    
  54.                     array[count]=queue3.get(0);       
  55.                     queue3.remove(0);    
  56.                     count++;    
  57.                 }       
  58.             }       
  59.         }       
  60.     }      
  61.   
  62. }   

 


註明：轉載請提示出處：http://blog.csdn.net/hguisu/article/details/7776068

總結：

 

 

來源：http://blog.csdn.net/cangchen/article/details/44816905

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程