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

算法思想：

簡單選擇排序的實現(xiàn)思想：比較+交換

從待排序序列中，找到關(guān)鍵字最小的元素；

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

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

算法代碼：

void print(int a[], int n ,int i){ cout<<"第"< 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<

四、堆排序（Heap Sort）

算法思想：

堆的概念

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

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

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

兩者對左右孩子的大小關(guān)系不做任何要求。

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

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

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

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

3. 對交換后的n-1個序列元素進行調(diào)整，使其滿足大頂堆的性質(zhì)；

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

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

void print(int a[], int n){ for(int j= 0; j= 0; --i) HeapAdjust(H,i,length);}/** * 堆排序算法 */void HeapSort(int H[],int length){ //初始堆 BuildingHeap(H, length); //從最后一個元素開始對序列進行調(diào)整 for (int i = length - 1; i > 0; --i) { //交換堆頂元素H[0]和堆中最后一個元素 int temp = H[i]; H[i] = H[0]; H[0] = temp; //每次交換堆頂元素和堆中最后一個元素之后，都要對堆進行調(diào)整 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<<"結(jié)果："; print(H,10); }?

五、冒泡排序（Bubble Sort）

算法思想：

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

算法代碼：

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）

算法思想：

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

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

算法步驟：

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

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

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

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

算法代碼：

void print(int a[], int n){ for(int j= 0; j= 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<<"結(jié)果："; print(a,10); }

七、歸并排序（Merge Sort）

算法思想：

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

算法步驟：

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

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

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

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

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

算法代碼：

void print(int a[], int n){ for(int j= 0; j

八、基數(shù)排序(Radix Sort)

算法思想：

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

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

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

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

算法代碼：

Void RadixSort(Node L[],length,maxradix){ int m,n,k,lsp; k=1;m=1; int temp[10][length-1]; Empty(temp); //清空臨時空間 while(k

四

使用Python實現(xiàn)

一、冒泡排序 冒泡排序算法的運作如下： ●比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。 ●對每一對相鄰元素作同樣的工作，從開始第一對到結(jié)尾的最后一對。這步做完后，最后的元素會是最大的數(shù)。 ●針對所有的元素重復以上的步驟，除了最后一個。 ●持續(xù)每次對越來越少的元素重復上面的步驟，直到?jīng)]有任何一對數(shù)字需要比較。 以上節(jié)選自維基百科 代碼實現(xiàn)：

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）是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最?。ù螅┰?，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續(xù)尋找最小（大）元素，然后放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。 以上節(jié)選自維基百科 代碼實現(xiàn)：

def findSmallest(arr): # 用于查找出數(shù)組中最小的元素，返回最小元素的索引。 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三、插入排序 步驟如下 ● 從第一個元素開始，該元素可以認為已經(jīng)被排序
●取出下一個元素，在已經(jīng)排序的元素序列中從后向前掃描
●如果該元素（已排序）大于新元素，將該元素移到下一位置
●重復步驟3，直到找到已排序的元素小于或者等于新元素的位置
●將新元素插入到該位置后 重復步驟2~5 以上節(jié)選自維基百科 代碼實現(xiàn)

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四、希爾排序 希爾排序通過將比較的全部元素分為幾個區(qū)域來提升插入排序的性能。這樣可以讓一個元素可以一次性地朝最終位置前進一大步。然后算法再取越來越小的步長進行排序，算法的最后一步就是普通的插入排序，但是到了這步，需排序的數(shù)據(jù)幾乎是已排好的了（此時插入排序較快）。 以上節(jié)選自維基百科 代碼實現(xiàn)：

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}個元素）： ●將序列每相鄰兩個數(shù)字進行歸并操作，形成{displaystyle ceil(n/2)}個序列，排序后每個序列包含兩/一個元素 ●若此時序列數(shù)不是1個則將上述序列再次歸并，形成{displaystyle ceil(n/4)}個序列，每個序列包含四/三個元素 ●重復步驟2，直到所有元素排序完畢，即序列數(shù)為1 以上節(jié)選自維基百科 代碼如下：

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 result def 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)?六、快速排序? 從數(shù)列中挑出一個元素，稱為“基準”（pivot），
●重新排序數(shù)列，所有比基準值小的元素擺放在基準前面，所有比基準值大的元素擺在基準后面（相同的數(shù)可以到任何一邊）。在這個分割結(jié)束之后，該基準就處于數(shù)列的中間位置。這個稱為分割（partition）操作。 ●遞歸地（recursively）把小于基準值元素的子數(shù)列和大于基準值元素的子數(shù)列排序。 ●遞歸到最底部時，數(shù)列的大小是零或一，也就是已經(jīng)排序好了。這個算法一定會結(jié)束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。 以上節(jié)選自維基百科 代碼如下：

def quick_sort(array): if len(array) < 2: return array else: 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)七、堆排序 若以升序排序說明，把數(shù)組轉(zhuǎn)換成最大堆積(Max-Heap Heap)，這是一種滿足最大堆積性質(zhì)(Max-Heap Property)的二叉樹：對于除了根之外的每個節(jié)點i, A[parent(i)] ≥ A[i]。 重復從最大堆積取出數(shù)值最大的結(jié)點(把根結(jié)點和最后一個結(jié)點交換，把交換后的最后一個結(jié)點移出堆)，并讓殘余的堆積維持最大堆積性質(zhì)。

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 # 創(chuàng)建最大堆 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?八、計數(shù)排序? 以上節(jié)選自維基百科
代碼如下：

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

五

總結(jié)

各種排序的穩(wěn)定性，時間復雜度和空間復雜度總結(jié)： 我們比較時間復雜度函數(shù)的情況：

時間復雜度函數(shù)O(n)的增長情況 所以對n較大的排序記錄。一般的選擇都是時間復雜度為O(nlog2n)的排序方法。 時間復雜度來說： (1)平方階(O(n2))排序 各類簡單排序:直接插入、直接選擇和冒泡排序； (2)線性對數(shù)階(O(nlog2n))排序 快速排序、堆排序和歸并排序； (3)O(n1+§))排序,§是介于0和1之間的常數(shù)。 希爾排序 (4)線性階(O(n))排序
基數(shù)排序，此外還有桶、箱排序。 說明： 當原表有序或基本有序時，直接插入排序和冒泡排序?qū)⒋蟠鬁p少比較次數(shù)和移動記錄的次數(shù)，時間復雜度可降至O（n）； 而快速排序則相反，當原表基本有序時，將蛻化為冒泡排序，時間復雜度提高為O（n2）； 原表是否有序，對簡單選擇排序、堆排序、歸并排序和基數(shù)排序的時間復雜度影響不大。 穩(wěn)定性： 排序算法的穩(wěn)定性:若待排序的序列中，存在多個具有相同關(guān)鍵字的記錄，經(jīng)過排序， 這些記錄的相對次序保持不變，則稱該算法是穩(wěn)定的；若經(jīng)排序后，記錄的相對 次序發(fā)生了改變，則稱該算法是不穩(wěn)定的。

穩(wěn)定性的好處：排序算法如果是穩(wěn)定的，那么從一個鍵上排序，然后再從另一個鍵上排序，第一個鍵排序的結(jié)果可以為第二個鍵排序所用?；鶖?shù)排序就是這樣，先按低位排序，逐次按高位排序，低位相同的元素其順序再高位也相同時是不會改變的。另外，如果排序算法穩(wěn)定，可以避免多余的比較； 穩(wěn)定的排序算法：冒泡排序、插入排序、歸并排序和基數(shù)排序 不是穩(wěn)定的排序算法：選擇排序、快速排序、希爾排序、堆排序 選擇排序算法準則： 每種排序算法都各有優(yōu)缺點。因此，在實用時需根據(jù)不同情況適當選用，甚至可以將多種方法結(jié)合起來使用。 選擇排序算法的依據(jù) 影響排序的因素有很多，平均時間復雜度低的算法并不一定就是最優(yōu)的。相反，有時平均時間復雜度高的算法可能更適合某些特殊情況。同時，選擇算法時還得考慮它的可讀性，以利于軟件的維護。一般而言，需要考慮的因素有以下四點：

1．待排序的記錄數(shù)目n的大小； 2．記錄本身數(shù)據(jù)量的大小，也就是記錄中除關(guān)鍵字外的其他信息量的大??； 3．關(guān)鍵字的結(jié)構(gòu)及其分布情況； 4．對排序穩(wěn)定性的要求。 設待排序元素的個數(shù)為n. 1）當n較大，則應采用時間復雜度為O(nlog2n)的排序方法：快速排序、堆排序或歸并排序序。 快速排序：是目前基于比較的內(nèi)部排序中被認為是最好的方法，當待排序的關(guān)鍵字是隨機分布時，快速排序的平均時間最短；

堆排序 ： 如果內(nèi)存空間允許且要求穩(wěn)定性的， 歸并排序：它有一定數(shù)量的數(shù)據(jù)移動，所以我們可能過與插入排序組合，先獲得一定長度的序列，然后再合并，在效率上將有所提高。 2） 當n較大，內(nèi)存空間允許，且要求穩(wěn)定性 =》歸并排序 3）當n較小，可采用直接插入或直接選擇排序。 直接插入排序：當元素分布有序，直接插入排序?qū)⒋蟠鬁p少比較次數(shù)和移動記錄的次數(shù)。 直接選擇排序 ：元素分布有序，如果不要求穩(wěn)定性，選擇直接選擇排序 4）一般不使用或不直接使用傳統(tǒng)的冒泡排序。 5）基數(shù)排序 它是一種穩(wěn)定的排序算法，但有一定的局限性： 1、關(guān)鍵字可分解。 2、記錄的關(guān)鍵字位數(shù)較少，如果密集更好 3、如果是數(shù)字時，最好是無符號的，否則將增加相應的映射復雜度，可先將其正負分開排序。 總結(jié) 以上所述是小編給大家介紹的必須知道的C語言 八大排序算法(收藏)，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對腳本之家網(wǎng)站的支持！

責任編輯：xj

原文標題：硬核！C語言八大排序算法，附動圖和詳細代碼解釋！

文章出處：【微信公眾號：玩轉(zhuǎn)單片機】歡迎添加關(guān)注！文章轉(zhuǎn)載請注明出處。