來源 ：C語言與程序設計、竹雨聽閑等

一

前言

如果說各種編程語言是程序員的招式，那么數據結構和算法就相當于程序員的內功。

想寫出精煉、優秀的代碼，不通過不斷的錘煉，是很難做到的。

二

八大排序算法

排序算法作為數據結構的重要部分，系統地學習一下是很有必要的。

1、排序的概念

排序是計算機內經常進行的一種操作，其目的是將一組“無序”的記錄序列調整為“有序”的記錄序列。

排序分為內部排序和外部排序。

若整個排序過程不需要訪問外存便能完成，則稱此類排序問題為內部排序。

反之，若參加排序的記錄數量很大，整個序列的排序過程不可能在內存中完成，則稱此類排序問題為外部排序。

2、排序分類

八大排序算法均屬于內部排序。如果按照策略來分類，大致可分為：交換排序、插入排序、選擇排序、歸并排序和基數排序。如下圖所示：

3、算法分析

1.插入排序
? *直接插入排序
? *希爾排序
2.選擇排序
? *簡單選擇排序
? *堆排序
3.交換排序
? *冒泡排序
? *快速排序
4.歸并排序
5.基數排序
不穩定排序：簡單選擇排序，快速排序，希爾排序，堆排序
穩定排序：冒泡排序，直接插入排序，歸并排序，奇數排序

1、插入排序

將第一個和第二個元素排好序，然后將第3個元素插入到已經排好序的元素中，依次類推（插入排序最好的情況就是數組已經有序了）

2、希爾排序

因為插入排序每次只能操作一個元素，效率低。元素個數N，取奇數k=N/2，將下標差值為k的數分為一組（一組元素個數看總元素個數決定），在組內構成有序序列，再取k=k/2，將下標差值為k的數分為一組，構成有序序列，直到k=1，然后再進行直接插入排序。

3、簡單選擇排序

選出最小的數和第一個數交換，再在剩余的數中又選擇最小的和第二個數交換，依次類推

4、堆排序

以升序排序為例，利用小根堆的性質（堆頂元素最小）不斷輸出最小元素，直到堆中沒有元素

1.構建小根堆
2.輸出堆頂元素
3.將堆低元素放一個到堆頂，再重新構造成小根堆，再輸出堆頂元素，以此類推

5、冒泡排序

改進1：如果某次冒泡不存在數據交換，則說明已經排序好了，可以直接退出排序
改進2：頭尾進行冒泡，每次把最大的沉底，最小的浮上去，兩邊往中間靠1

6、快速排序

選擇一個基準元素，比基準元素小的放基準元素的前面，比基準元素大的放基準元素的后面，這種動作叫分區，每次分區都把一個數列分成了兩部分，每次分區都使得一個數字有序，然后將基準元素前面部分和后面部分繼續分區，一直分區直到分區的區間中只有一個元素的時候，一個元素的序列肯定是有序的嘛，所以最后一個升序的序列就完成啦。

7、歸并排序

將一個無序的數列一直一分為二，直到分到序列中只有一個數的時候，這個序列肯定是有序的，因為只有一個數，然后將兩個只含有一個數字的序列合并為含有兩個數字的有序序列，這樣一直進行下去，最后就變成了一個大的有序數列

8、基數排序

找到最大的數，開個比最大的數大一點的數組，遍歷每個元素，某個元素為k，則a[k]++,最好遍歷數組a，a[k]等于多少就輸出多少個k。只能處理整型數

三

具體排序講解

下面針對不同排序進行一一講解。

一、直接插入排序（Insertion Sort)

算法思想：

直接插入排序的核心思想就是：將數組中的所有元素依次跟前面已經排好的元素相比較，如果選擇的元素比已排序的元素小，則交換，直到全部元素都比較過 因此，從上面的描述中我們可以發現，直接插入排序可以用兩個循環完成：

???????第一層循環：遍歷待比較的所有數組元素

????????第二層循環：將本輪選擇的元素(selected)與已經排好序的元素(ordered)相比較。如果：selected > ordered，那么將二者交換。

算法代碼：

void print(int a[], int n ,int i){cout<<i <<":";for(int j= 0; j<8; j++){cout<<a[j] <<" ";}cout<<endl; }? void InsertSort(int a[], int n) {for(int i= 1; i<n; i++){if(a[i] < a[i-1]){ //若第i個元素大于i-1元素，直接插入。小于的話，移動有序表后插入int j= i-1; int x = a[i]; //復制為哨兵，即存儲待排序元素a[i] = a[i-1]; //先后移一個元素while(x < a[j]){ //查找在有序表的插入位置a[j+1] = a[j];j--; //元素后移}a[j+1] = x; //插入到正確位置}print(a,n,i); //打印每趟排序的結果}}int main(){int a[8] = {3,1,5,7,2,4,9,6};InsertSort(a,8);print(a,8,8); }

二、希爾排序（Shell' s Sort）

算法思想:

希爾排序，也稱遞減增量排序算法，是插入排序的一種更高效的改進版本。但希爾排序是非穩定排序算法。

希爾排序的基本思想是：先將整個待排序的記錄序列分割成為若干子序列分別進行直接插入排序，待整個序列中的記錄“基本有序”時，再對全體記錄進行依次直接插入排序。

算法步驟：

??? 1.選擇一個增量序列t1，t2，…，tk，其中ti>tj，tk=1；

??? 2.按增量序列個數k，對序列進行k 趟排序；

??? 3.每趟排序，根據對應的增量ti，將待排序列分割成若干長度為m 的子序列，分別對各子表進行直接插入排序。僅增量因子為1 時，整個序列作為一個表來處理，表長度即為整個序列的長度。

算法代碼:

void print(int a[], int n ,int i){cout<<i <<":";for(int j= 0; j<8; j++){cout<<a[j] <<" ";}cout<<endl; } /*** 直接插入排序的一般形式** @param int dk 縮小增量，如果是直接插入排序，dk=1**/void ShellInsertSort(int a[], int n, int dk) {for(int i= dk; i<n; ++i){if(a[i] < a[i-dk]){ //若第i個元素大于i-1元素，直接插入。小于的話，移動有序表后插入int j = i-dk; int x = a[i]; //復制為哨兵，即存儲待排序元素a[i] = a[i-dk]; //首先后移一個元素while(x < a[j]){ //查找在有序表的插入位置a[j+dk] = a[j];j -= dk; //元素后移}a[j+dk] = x; //插入到正確位置}print(a, n,i );}}//?先按增量d（n/2,n為要排序數的個數進行希爾排序 void shellSort(int a[], int n){int dk = n/2;while( dk >= 1 ){ShellInsertSort(a, n, dk);dk = dk/2;} } int main(){int a[8] = {3,1,5,7,2,4,9,6};//ShellInsertSort(a,8,1); //直接插入排序shellSort(a,8); //希爾插入排序print(a,8,8); }

三、簡單選擇排序（Selection Sort）

算法思想：

簡單選擇排序的實現思想：比較+交換

從待排序序列中，找到關鍵字最小的元素；

如果最小元素不是待排序序列的第一個元素，將其和第一個元素互換；

從余下的 N - 1 個元素中，找出關鍵字最小的元素，重復(1)、(2)步，直到排序結束。因此我們可以發現，簡單選擇排序也是通過兩層循環實現。第一層循環：依次遍歷序列當中的每一個元素 第二層循環：將遍歷得到的當前元素依次與余下的元素進行比較，符合最小元素的條件，則交換。

算法代碼：

void print(int a[], int n ,int i){cout<<"第"<<i+1 <<"趟 : ";for(int j= 0; j<8; j++){cout<<a[j] <<" ";}cout<<endl; } /*** 數組的最小值** @return int 數組的鍵值*/ int SelectMinKey(int a[], int n, int i) {int k = i;for(int j=i+1 ;j< n; ++j) {if(a[k] > a[j]) k = j;}return k; }/*** 選擇排序**/ void selectSort(int a[], int n){int key, tmp;for(int i = 0; i< n; ++i) {key = SelectMinKey(a, n,i); //選擇最小的元素if(key != i){tmp = a[i]; a[i] = a[key]; a[key] = tmp; //最小元素與第i位置元素互換}print(a, n , i);} } int main(){int a[8] = {3,1,5,7,2,4,9,6};cout<<"初始值：";for(int j= 0; j<8; j++){cout<<a[j] <<" ";}cout<<endl<<endl;selectSort(a, 8);print(a,8,8); }

四、堆排序（Heap Sort）

算法思想：

堆的概念

堆：本質是一種數組對象。特別重要的一點性質：任意的葉子節點小于（或大于）它所有的父節點。對此，又分為大頂堆和小頂堆：

大頂堆要求節點的元素都要大于其孩子。

小頂堆要求節點元素都小于其左右孩子。

兩者對左右孩子的大小關系不做任何要求。

利用堆排序，就是基于大頂堆或者小頂堆的一種排序方法。下面，我們通過大頂堆來實現。

基本思想：堆排序可以按照以下步驟來完成：

??? 1.首先將序列構建稱為大頂堆；（這樣滿足了大頂堆那條性質：位于根節點的元素一定是當前序列的最大值）

??? 2. 取出當前大頂堆的根節點，將其與序列末尾元素進行交換；（此時：序列末尾的元素為已排序的最大值；由于交換了元素，當前位于根節點的堆并不一定滿足大頂堆的性質）

??? 3. 對交換后的n-1個序列元素進行調整，使其滿足大頂堆的性質；

? ????4. 重復2.3步驟，直至堆中只有1個元素為止

下面是基于大頂堆的堆排序算法代碼：

void print(int a[], int n){for(int j= 0; j<n; j++){cout<<a[j] <<" ";}cout<<endl; } /*** 已知H[s…m]除了H[s] 外均滿足堆的定義* 調整H[s],使其成為大頂堆.即將對第s個結點為根的子樹篩選, ** @param H是待調整的堆數組* @param s是待調整的數組元素的位置*?@param?length是數組的長度*/ void HeapAdjust(int H[],int s, int length) {int tmp = H[s];int child = 2*s+1; //左孩子結點的位置。(i+1 為當前調整結點的右孩子結點的位置)while (child < length) {if(child+1 <length && H[child]<H[child+1]) { // 如果右孩子大于左孩子(找到比當前待調整結點大的孩子結點)++child ;}if(H[s]<H[child]) { // 如果較大的子結點大于父結點H[s] = H[child]; // 那么把較大的子結點往上移動，替換它的父結點s = child; // 重新設置s ,即待調整的下一個結點的位置child = 2*s+1;} else { // 如果當前待調整結點大于它的左右孩子，則不需要調整，直接退出break;}H[s] = tmp; // 當前待調整的結點放到比其大的孩子結點位置上}print(H,length); }/*** 初始堆進行調整* 將H[0..length-1]建成堆* 調整完之后第一個元素是序列的最小的元素*/ void BuildingHeap(int H[], int length) { //最后一個有孩子的節點的位置 i= (length -1) / 2for (int i = (length -1) / 2 ; i >= 0; --i)HeapAdjust(H,i,length); } /*** 堆排序算法*/ void HeapSort(int H[],int length) {//初始堆BuildingHeap(H, length);//從最后一個元素開始對序列進行調整for (int i = length - 1; i > 0; --i){//交換堆頂元素H[0]和堆中最后一個元素int temp = H[i]; H[i] = H[0]; H[0] = temp;//每次交換堆頂元素和堆中最后一個元素之后，都要對堆進行調整HeapAdjust(H,0,i);} } int main(){int H[10] = {3,1,5,7,2,4,9,6,10,8};cout<<"初始值：";print(H,10);HeapSort(H,10);//selectSort(a, 8);cout<<"結果：";print(H,10);}

五、冒泡排序（Bubble Sort）

算法思想：

冒泡遍歷所有的數據，每次對相鄰元素進行兩兩比較，如果順序和預先規定的順序不一致，則進行位置交換；這樣一次遍歷會將最大或最小的數據上浮到頂端，之后再重復同樣的操作，直到所有的數據有序。這個算法的名字由來是因為越大的元素會經由交換慢慢“浮”到數列的頂端。

算法代碼：

void bubbleSort(int a[], int n){for(int i =0 ; i< n-1; ++i) {for(int j = 0; j < n-i-1; ++j) {if(a[j] > a[j+1]){int tmp = a[j] ; a[j] = a[j+1] ; a[j+1] = tmp;}}} }

六、快速排序（Quick Sort）

算法思想：

快速排序是由東尼·霍爾所發展的一種排序算法。在平均狀況下，排序 n 個項目要Ο(n logn)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況并不常見。事實上，快速排序通常明顯比其他Ο(n log n) 算法更快，因為它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來

快速排序使用分治法（Divide and conquer）策略來把一個串行（list）分為兩個子串行（sub-lists）。

算法步驟：

從數列中挑出一個元素，稱為 “基準”（pivot）。

重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的后面（相同的數可以到任一邊）。在這個分區退出之后，該基準就處于數列的中間位置。這個稱為分區（partition）操作。

遞歸地（recursive）把小于基準值元素的子數列和大于基準值元素的子數列排序。

遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個算法總會退出，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。

算法代碼：

void print(int a[], int n){for(int j= 0; j<n; j++){cout<<a[j] <<" ";}cout<<endl; }void swap(int *a, int *b) {int tmp = *a;*a = *b;*b = tmp; }int partition(int a[], int low, int high) {int privotKey = a[low]; //基準元素while(low < high){ //從表的兩端交替地向中間掃描while(low < high && a[high] >= privotKey) --high; //從high 所指位置向前搜索，至多到low+1 位置。將比基準元素小的交換到低端swap(&a[low], &a[high]);while(low < high && a[low] <= privotKey ) ++low;swap(&a[low], &a[high]);}print(a,10);return low; }void quickSort(int a[], int low, int high){if(low < high){int privotLoc = partition(a, low, high); //將表一分為二quickSort(a, low, privotLoc -1); //遞歸對低子表遞歸排序quickSort(a, privotLoc + 1, high); //遞歸對高子表遞歸排序} }int main(){int a[10] = {3,1,5,7,2,4,9,6,10,8};cout<<"初始值：";print(a,10);quickSort(a,0,9);cout<<"結果：";print(a,10);}

七、歸并排序（Merge Sort）

算法思想：

歸并排序（Merge sort）是建立在歸并操作上的一種有效的排序算法。該算法是采用分治法（Divide and Conquer）的一個非常典型的應用。

算法步驟：

申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合并后的序列；

設定兩個指針，最初位置分別為兩個已經排序序列的起始位置；

比較兩個指針所指向的元素，選擇相對小的元素放入到合并空間，并移動指針到下一位置；

重復步驟3直到某一指針達到序列尾；

將另一序列剩下的所有元素直接復制到合并序列尾。

算法代碼：

void print(int a[], int n){for(int j= 0; j<n; j++){cout<<a[j] <<" ";}cout<<endl; }//將r[i…m]和r[m +1 …n]歸并到輔助數組rf[i…n] void Merge(ElemType *r,ElemType *rf, int i, int m, int n) {int j,k;for(j=m+1,k=i; i<=m && j <=n ; ++k){if(r[j] < r[i]) rf[k] = r[j++];else rf[k] = r[i++];}while(i <= m) rf[k++] = r[i++];while(j <= n) rf[k++] = r[j++];print(rf,n+1); }void MergeSort(ElemType *r, ElemType *rf, int lenght) { int len = 1;ElemType *q = r ;ElemType *tmp ;while(len < lenght) {int s = len;len = 2 * s ;int i = 0;while(i+ len <lenght){Merge(q, rf, i, i+ s-1, i+ len-1 ); //對等長的兩個子表合并i = i+ len;}if(i + s < lenght){Merge(q, rf, i, i+ s -1, lenght -1); //對不等長的兩個子表合并}tmp = q; q = rf; rf = tmp; //交換q,rf，以保證下一趟歸并時，仍從q 歸并到rf} }int main(){int a[10] = {3,1,5,7,2,4,9,6,10,8};int b[10];MergeSort(a, b, 10);print(b,10);cout<<"結果：";print(a,10); }

八、基數排序(Radix Sort)

算法思想：

基數排序：通過序列中各個元素的值，對排序的N個元素進行若干趟的“分配”與“收集”來實現排序。

分配：我們將L[i]中的元素取出，首先確定其個位上的數字，根據該數字分配到與之序號相同的桶中 。

收集：當序列中所有的元素都分配到對應的桶中，再按照順序依次將桶中的元素收集形成新的一個待排序列L[ ] 。

對新形成的序列L[]重復執行分配和收集元素中的十位、百位...直到分配完該序列中的最高位，則排序結束。

算法代碼：

Void RadixSort(Node L[],length,maxradix) {int m,n,k,lsp;k=1;m=1;int temp[10][length-1];Empty(temp); //清空臨時空間while(k<maxradix) //遍歷所有關鍵字{for(int i=0;i<length;i++) //分配過程{if(L[i]<m)Temp[0][n]=L[i];elseLsp=(L[i]/m)%10; //確定關鍵字Temp[lsp][n]=L[i];n++;}CollectElement(L,Temp); //收集n=0;m=m*10;k++;} }

四

使用Python實現

一、冒泡排序

冒泡排序算法的運作如下：

●?比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

●?對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。這步做完后，最后的元素會是最大的數。

●?針對所有的元素重復以上的步驟，除了最后一個。

●?持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

以上節選自維基百科

代碼實現：

def bubble_sort(numberlist):length = len(numberlist)for i in range(length):for j in range(1, length - i):if numberlist[j - 1] > numberlist[j]:numberlist[j], numberlist[j - 1] = numberlist[j - 1], numberlist[j]return numberlist

二、選擇排序

選擇排序（Selection sort）是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。

以上節選自維基百科

代碼實現：

def findSmallest(arr): # 用于查找出數組中最小的元素，返回最小元素的索引。 smallest = arr[0] smallest_index = 0 for i in range(1, len(arr)): if smallest > arr[i]: smallest = arr[i] smallest_index = i return smallest_index def selectSort(arr): newArr = [] while arr: smallest = findSmallest(arr) newArr.append(arr.pop(smallest)) return newArr

三、插入排序

步驟如下

● 從第一個元素開始，該元素可以認為已經被排序
●?取出下一個元素，在已經排序的元素序列中從后向前掃描
●?如果該元素（已排序）大于新元素，將該元素移到下一位置
●?重復步驟3，直到找到已排序的元素小于或者等于新元素的位置
●?將新元素插入到該位置后

重復步驟2~5

以上節選自維基百科

代碼實現

def insert_sort(data): for k in range(1, len(data)): cur = data[k] j = k while j > 0 and data[j - 1] > cur: data[j] = data[j - 1] j -= 1 data[j] = cur return data

四、希爾排序

希爾排序通過將比較的全部元素分為幾個區域來提升插入排序的性能。這樣可以讓一個元素可以一次性地朝最終位置前進一大步。然后算法再取越來越小的步長進行排序，算法的最后一步就是普通的插入排序，但是到了這步，需排序的數據幾乎是已排好的了（此時插入排序較快）。

以上節選自維基百科

代碼實現：

def shell_sort(numberlist): length = len(numberlist) gap = length // 2 while gap > 0: for i in range(gap, length): temp = numberlist[i] j = i while j >= gap and numberlist[j - gap] > temp: numberlist[j] = numberlist[j - gap] j -= gap numberlist[j] = temp gap = gap // 2 return numberlist

五、歸并排序

原理如下（假設序列共有{displaystyle n}個元素）：

●?將序列每相鄰兩個數字進行歸并操作，形成{displaystyle ceil(n/2)}個序列，排序后每個序列包含兩/一個元素

●?若此時序列數不是1個則將上述序列再次歸并，形成{displaystyle ceil(n/4)}個序列，每個序列包含四/三個元素

●?重復步驟2，直到所有元素排序完畢，即序列數為1

以上節選自維基百科

代碼如下：

def merge(left, right): result = [] while left and right: if left[0] < right[0]: result.append(left.pop(0)) else: result.append(right.pop(0)) if left: result += left if right: result += right return resultdef merge_sort(numberlist): if len(numberlist) <= 1: return numberlist mid = len(numberlist) // 2 left = numberlist[:mid] right = numberlist[mid:]left = merge_sort(left) right = merge_sort(right) return merge(left, right)

六、快速排序

從數列中挑出一個元素，稱為“基準”（pivot），

●?重新排序數列，所有比基準值小的元素擺放在基準前面，所有比基準值大的元素擺在基準后面（相同的數可以到任何一邊）。在這個分割結束之后，該基準就處于數列的中間位置。這個稱為分割（partition）操作。

●?遞歸地（recursively）把小于基準值元素的子數列和大于基準值元素的子數列排序。

●?遞歸到最底部時，數列的大小是零或一，也就是已經排序好了。這個算法一定會結束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。

以上節選自維基百科

代碼如下：

def quick_sort(array):if len(array) < 2:return arrayelse:pivot = array[0]less = [i for i in array[1:] if i <= pivot]greater = [i for i in array[1:] if i > pivot]return quick_sort(less) + [pivot] + quick_sort(greater)

七、堆排序

若以升序排序說明，把數組轉換成最大堆積(Max-Heap Heap)，這是一種滿足最大堆積性質(Max-Heap Property)的二叉樹：對于除了根之外的每個節點i, A[parent(i)] ≥ A[i]。

重復從最大堆積取出數值最大的結點(把根結點和最后一個結點交換，把交換后的最后一個結點移出堆)，并讓殘余的堆積維持最大堆積性質。

def heap_sort(numberlist): length = len(numberlist) def sift_down(start, end): root = start while True: child = 2 * root + 1 if child > end: break if child + 1 <= end and numberlist[child] < numberlist[child + 1]: child += 1 if numberlist[root] < numberlist[child]: numberlist[root], numberlist[child] = numberlist[child], numberlist[root] root = child else: break # 創建最大堆 for start in range((length - 2) // 2, -1, -1): sift_down(start, length - 1) # 堆排序 for end in range(length - 1, 0, -1): numberlist[0], numberlist[end] = numberlist[end], numberlist[0] sift_down(0, end - 1)return numberlist

八、計數排序

以上節選自維基百科

代碼如下：

def counting_sort(numberlist, maxnumber): # maxnumber為數組中的最大值 length = len(numberlist) # 待排序數組長度 b = [0 for i in range(length)] # 設置輸出序列，初始化為0 c = [0 for i in range(maxnumber+ 1)] # 設置技術序列，初始化為0 for j in numberlist: c[j] = c[j] + 1 for i in range(1, len(c)): c[i] = c[i] + c[i - 1] for j in numberlist: b[c[j] - 1] = j c[j] = c[j] - 1 return b

五

總結

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

我們比較時間復雜度函數的情況：

??????????? ??????????????

時間復雜度函數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較小，可采用直接插入或直接選擇排序。

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

直接選擇排序 ：元素分布有序，如果不要求穩定性，選擇直接選擇排序

4）一般不使用或不直接使用傳統的冒泡排序。

5）基數排序

它是一種穩定的排序算法，但有一定的局限性：

　　1、關鍵字可分解。

　　2、記錄的關鍵字位數較少，如果密集更好

　　3、如果是數字時，最好是無符號的，否則將增加相應的映射復雜度，可先將其正負分開排序。

總結

以上所述是小編給大家介紹的必須知道的C語言 八大排序算法(收藏)，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對腳本之家網站的支持！

-END-

往期好文合集

電路與愛情<<戳這里

是否要從單片機轉嵌入式Linux？<<戳這里

分享GitHub上一些嵌入式相關的高星開源項目<<戳這里

??最 后??

?

若覺得文章不錯，轉發分享，也是我們繼續更新的動力。

5T資源大放送！包括但不限于：C/C++，Linux，Python，Java，PHP，人工智能，PCB、FPGA、DSP、labview、單片機、等等！

在公眾號內回復「更多資源」，即可免費獲取，期待你的關注~

長按識別圖中二維碼關注

總結

以上是生活随笔為你收集整理的硬核！C语言八大排序算法，附动图和详细代码解释！的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。