各種排序算法時間復雜度、穩定性、初始序列是否對元素比較次數有關

怎么記憶穩定性：

總過四大類排序：插入、選擇、交換、歸並（基數排序暫且不算）

比較高級一點的（時間復雜度低一點得）shell排序，堆排序，快速排序（除了歸並排序）都是不穩定的，在加上低一級的選擇排序是不穩定的。

比較低級一點的（時間復雜度高一點的）插入排序，               冒泡排序，歸並排序，基數排序都是穩定的。

（4種不穩定，4種穩定）。

怎么記憶初始序列是否對元素的比較次數有關：

[cpp] view plaincopy

1. /**
2.   * @brief 嚴版數據結構書代碼
3.   *        最好的情況,數組本身有序，就只需執行n-1次比較，此時時間復雜度為O(n);
4.   *        最壞的情況，數組本身逆序，要執行n(n-1)/2次，此時時間復雜度為O(n^2);
5.   */
6. void _insertSort(int R[], int n) 
7. { 
8. int i, j, temp; 
9. for ( i = 1; i < n; ++i ) { 
10. if ( R[i] < R[i - 1] ) {//將R[i]插入有序字表
11.             temp = R[i];        //設置哨兵
12. for ( j = i - 1; R[j] > temp; --j ) { 
13.                 R[j+1] = R[j]; 
14.             } 
15.             R[j+1] = temp; 
16.         } 
17.     } 
18. } 

對於直接插入排序:

當最好的情況，如果原來本身就是有序的，比較次數為n-1次（分析（while (j >= 0 && temp < R[j])）這條語句）,時間復雜度為O(n)。

當最壞的情況，原來為逆序，比較次數為2+3+...+n=(n+2)(n-1)/2次，而記錄的移動次數為i+1(i=1,2...n)=(n+4)(n-1)/2次。

如果序列是隨機的，根據概率相同的原則，平均比較和移動的次數為n^2/4.

[cpp] view plaincopy

1. /**
2.   * @brief 嚴版數據結構 選擇排序
3.   *        采用"選擇排序"對長度為n的數組進行排序,時間復雜度最好，最壞都是O(n^2)
4.   *        當最好的時候，交換次數為0次，比較次數為n(n-1)/2
5.   *        最差的時候，也就初始降序時，交換次數為n-1次，最終的排序時間是比較與交換的次數總和，
6.   *        總的時間復雜度依然為O(n^2)
7.   */
8. void _selectSort(int R[], int n) 
9. { 
10. int i, j, temp, index; 
11. for ( i = 0; i < n; ++i ) { 
12.         index = i; 
13. for ( j = i + 1; j < n; ++j ) { 
14. if ( R[index] > R[j] ) { 
15.                 index = j;//index中存放關鍵碼最小記錄的下標
16.             } 
17.         } 
18. if (index != i) { 
19.             temp = R[i]; 
20.             R[i] = R[index]; 
21.             R[index] = temp; 
22.         } 
23.     } 
24. } 

選擇排序不關心表的初始次序，它的最壞情況的排序時間與其最佳情況沒多少區別，其比較次數都為 n(n-1)/2，交換次數最好的時候為0，最差的時候為n-1，盡管和冒泡排序同為O(n)，但簡單選擇排序性能上要優於冒泡排序。但選擇排序可以   非常有效的移動元素。因此對次序近乎正確的表，選擇排序可能比插入排序慢很多。

[cpp] view plaincopy

1. /**
2.   * @brief     改進的冒泡排序
3.   * @attention 時間復雜度，最好的情況，要排序的表本身有序，比較次數n-1,沒有數據交換,時間復雜度O(n)。
4.   *            最壞的情況，要排序的表本身逆序，需要比較n(n-1)/2次，並做等數量級的記錄移動，總時間復雜度為O(n^2).
5.   */
6. void bubbleSort2(int R[], int n) 
7. { 
8. int i, j, temp; 
9. bool flag = TRUE;   //flag用來作為標記
11. for ( i = 0; i < n && flag; ++i ) { 
12.         flag = FALSE; 
13. for ( j = n - 1; j > i; --j ) { 
14. if (R[j] < R[j - 1]) { 
15.                 temp = R[j]; 
16.                 R[j] = R[j - 1]; 
17.                 R[j - 1] = temp; 
18.                 flag = TRUE;//如果有數據交換，則flag為true
19.             } 
20.         } 
21.     } 
22. } 

冒泡排序：

最好的情況，n-1次比較，移動次數為0，時間復雜度為O(n)。

最壞的情況，n(n-1)/2次比較，等數量級的移動，時間復雜度為O(O^2)。

[cpp] view plaincopy

1. /**
2.   * @brief 希爾排序, 對於長度為n的數組,經過 "希爾排序" 輸出
3.   */
4. void shellSort(int R[], int n) 
5. { 
6. int i, j, temp; 
7. int k = n / 2; 
8. while (k >= 1) { 
9. for (i = k; i < n; ++i) { 
10.             temp = R[i]; 
11.             j = i - k; 
12. while (R[j] < temp && j >= 0) { 
13.                 R[j+k] = R[j]; 
14.                 j = j - k; 
15.             } 
16.             R[j+k] = temp; 
17.         } 
18.         k = k / 2; 
19.     } 

希爾排序初始序列對元素的比較次數有關。

[cpp] view plaincopy

1. /**
2.   * @brief     構建 大頂堆
3.   * @attention 個人版本，堆排序
4.   */
5. void heapAdjust(int R[], int start, int end) 
6. { 
7. int j, temp; 
8.     temp = R[start]; 
9. for ( j = 2 * start + 1; j <= end; j = j * 2 + 1 ) { 
11. if ( j < end && R[j] < R[j + 1] ) { 
12.             ++j; 
13.         } 
14. if ( temp >  R[j] ) { 
15. break; 
16.         } 
17.         R[start] = R[j]; 
18.         start = j; 
19.     } 
20.     R[start] = temp; 
21. } 
23. /**
24.   * @brief 堆排序
25.   * @param R為待排序的數組，size為數組的長度
26.   *  時間復雜度:構建大(小)頂堆，完全二叉樹的高度為log(n+1)，因此對每個結點調整的時間復雜度為O(logn)
27.   *           兩個循環，第一個循環做的操作次數為n/2，第二個操作次數為(n-1)，因此時間復雜度為O(nlogn)
28.   */
29. void heapSort(int R[], int size) 
30. { 
31. int i, temp; 
32. for ( i = size / 2 - 1; i >= 0; --i ) { 
33.         heapAdjust(R, i, size); 
34.     } 
35. for ( i = size - 1; i >= 0; --i ) { 
36.         temp = R[i]; 
37.         R[i] = R[0]; 
38.         R[0] = temp;//表尾和表首的元素交換
39.         heapAdjust(R, 0, i - 1);//把表首的元素換成表尾的元素后，重新構成大頂堆，因為除表首的元素外，
40. //后面的結點都滿足大頂堆的條件，故heapAdjust()的第二個參數只需為0
41.     } 
42. } 

[cpp] view plaincopy

1. /**
2.   * @brief 將有序的長度為n的數組a[]和長度為m的b[]歸並為有序的數組c[]
3.   *        只要從比較二個數列的第一個數，誰小就先取誰，取了之后在對應的數列中刪除這個數。
4.   *        然后再進行比較，如果有數列為空，那直接將另一個數列的數據依次取出即可。
5.   *        將兩個有序序列a[first...mid]和a[mid...last]合並
6.   */
7. void mergeArray(int a[], int first, int mid, int last, int tmp[]) 
8. { 
9. int i = first, j = mid + 1; 
10. int k = 0; 
11. while ( i <= mid && j <= last ) { 
12. if ( a[i] <= a[j] ) 
13.             tmp[k++] = a[i++]; 
14. else
15.             tmp[k++] = a[j++]; 
16.     } 
17. while ( i <= mid ) { 
18.         tmp[k++] = a[i++]; 
19.     } 
20. while ( j <= last ) { 
21.         tmp[k++] = a[j++]; 
22.     } 
23. for (i = 0; i < k; i++) {//這里千萬不能丟了這個
24.         a[first + i] = tmp[i]; 
25.     } 
26. } 
27. /**
28.   * @brief 歸並排序，其的基本思路就是將數組分成二組A，B，如果這二組組內的數據都是有序的，
29.   *        那么就可以很方便的將這二組數據進行排序。如何讓這二組組內數據有序了？
31.   *        可以將A，B組各自再分成二組。依次類推，當分出來的小組只有一個數據時，
32.   *        可以認為這個小組組內已經達到了有序，然后再合並相鄰的二個小組就可以了。這樣通過先 (遞歸) 的分解數列，
33.   *        再 (合並) 數列就完成了歸並排序。
34.   */
35. void mergeSort(int a[], int first, int last, int tmp[]) 
36. { 
37. int mid; 
38. if ( first < last ) { 
39.         mid = ( first + last ) / 2; 
40.         mergeSort(a, first, mid, tmp);  //左邊有序
41.         mergeSort(a, mid + 1, last, tmp);   //右邊有序
42.         mergeArray(a, first, mid, last, tmp); 
43.     } 
44. } 

[cpp] view plaincopy

1. /**
2.   * @brief 雖然快速排序稱為分治法，但分治法這三個字顯然無法很好的概括快速排序的全部步驟。
3.   *        因此我的對快速排序作了進一步的說明：挖坑填數+分治法：
4.   * @param R為待排數組，low和high為無序區
5.   *        時間復雜度：最好O(nlogn),最壞O(n^2)，平均O(nlogn)，空間復雜度O(logn)；
6.   */
7. void quickSort(int R[], int low, int high) 
8. { 
9. if ( low < high ) { 
10. int i = low, j = high, temp = R[low]; 
12. while ( i < j ) { 
13. //從右往左掃描，如果數組元素大於temp，則繼續，直至找到第一個小於temp的元素
14. while ( i < j && R[j] >= temp ) { 
15.                 --j; 
16.             } 
17. if ( i < j ) { 
18.                 R[i++] = R[j]; 
19.             } 
20. while ( i < j && R[i] <= temp ) { 
21.                 ++i; 
22.             } 
23. if ( i < j ) { 
24.                 R[j--] = R[i]; 
25.             } 
26.         } 
27.         R[i] = temp; 
28.         quickSort(R, low, i - 1); 
29.         quickSort(R, i + 1, high); 
30.     } 
31. } 

各排序算法整體分析

冒泡排序、插入排序、希爾排序以及快速排序對數據的有序性比較敏感，尤其是冒泡排序和插入排序；

選擇排序不關心表的初始次序，它的最壞情況的排序時間與其最佳情況沒多少區別，其比較次數為 n(n-1)/2，但選擇排序可以   非常有效的移動元素。因此對次序近乎正確的表，選擇排序可能比插入排序慢很多。

冒泡排序在最優情況下只需要經過n-1次比較即可得出結果（即對於完全正序的表），最壞情況下也要進行n(n-1)/2 次比較，與選擇排序的比較次數相同，但數據交換的次數要多余選擇排序，因為選擇排序的數據交換次數頂多為 n-1，而冒泡排序最壞情況下的數據交換n(n-1)/2 。冒泡排序不一定要進行 趟，但由於它的記錄移動次數較多，所以它的平均時間性能比插入排序要差一些。

插入排序在最好的情況下有最少的比較次數 ，但是它在元素移動方面效率非常低下，因為它只與毗鄰的元素進行比較，效率比較低。

希爾排序實際上是預處理階段優化后的插入排序，一般而言，在 比較大時，希爾排序要明顯優於插入排序。

快速排序采用的“大事化小，小事化了”的思想，用遞歸的方法，將原問題分解成若干規模較小但與原問題相似的子問題進行求解。快速算法的平均時間復雜度為O(nlogn) ，平均而言，快速排序是基於關鍵字比較的內部排序算法中速度最快者；但是由於快速排序采用的是遞歸的方法，因此當序列的長度比較大時，對系統棧占用會比較多。快速算法尤其適用於隨機序列的排序。

因此，平均而言，對於一般的隨機序列順序表而言，上述幾種排序算法性能從低到高的順序大致為：冒泡排序、插入排序、選擇排序、希爾排序、快速排序。但這個優劣順序不是絕對的，在不同的情況下，甚至可能出現完全的性能逆轉。

對於序列初始狀態基本有正序，可選擇對有序性較敏感的如插入排序、冒泡排序、選擇排序等方法

對於序列長度 比較大的隨機序列，應選擇平均時間復雜度較小的快速排序方法。

各種排序算法都有各自的優缺點，適應於不同的應用環境，因此在選擇一種排序算法解決實際問題之前，應當先分析實際問題的類型，再結合各算法的特點，選擇一種合適的算法

這里特別介紹下快速排序：

快速排序的時間主要耗費在划分操作上，對長度為k的區間進行划分，需要k-1次關鍵字比較。

（1）最壞的時間復雜度

最壞情況是每次划分選取的基准都是當前無序區中關鍵字最小（或最大）的記錄，划分的結果是基准左邊的子區間為空（或右邊的子區間為空），而划分所得的另一個非空的子區間中記錄數目，僅僅比划分前的的無序區中記錄個數減少一個。

    因此，快速排序必須做n-1次划分，第i次划分開始區間長度為n-i+1,所需的比較次數為n-i(1<=i<=n-1),故總的比較次數達到最大值：n(n-1)/2；

    如果按上面給出的划分算法，每次取當前無序區的第1個記錄為基准，那么當文件的記錄已按遞增序(或遞減序)排列時，每次划分所取的基准就是當前無序區中關鍵字最小(或最大)的記錄，則快速排序所需的比較次數反而最多。

（2）最壞的時間復雜度

在最好情況下，每次划分所取的基准都是當前無序區的"中值"記錄，划分的結果是基准的左、右兩個無序子區間的長度大致相等。總的關鍵字比較次數：

        0(nlgn)

（3）平均時間復雜度

    盡管快速排序的最壞時間為O(n2)，但就平均性能而言，它是基於關鍵字比較的內部排序算法中速度最快者，快速排序亦因此而得名。它的平均時間復雜度為O(nlgn)。

（4）空間復雜度

    快速排序在系統內部需要一個棧來實現遞歸。若每次划分較為均勻，則其遞歸樹的高度為O(lgn)，故遞歸后需棧空間為O(lgn)。最壞情況下，遞歸樹的高度為O(n)，所需的棧空間為O(n)。

 

轉載：http://blog.csdn.net/hr10707020217/article/details/10581371