C 數據結構之十大排序

排序算法是《數據結構與算法》中最基本的算法之一。

排序算法可以分為內部排序和外部排序，內部排序是數據記錄在內存中進行排序，而外部排序是因排序的數據很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。常見的內部排序算法有：插入排序、希爾排序、選擇排序、冒泡排序、歸并排序、快速排序、堆排序、基數排序等。用一張圖概括：

關于時間復雜度

• 平方階 (O(n2)) 排序 各類簡單排序：直接插入、直接選擇和冒泡排序。
• 線性對數階 (O(nlog2n)) 排序 快速排序、堆排序和歸并排序；
• O(n1+§)) 排序，§ 是介于 0 和 1 之間的常數。 希爾排序
• 線性階 (O(n)) 排序 基數排序，此外還有桶、箱排序。

關于穩定性

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

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

名詞解釋

n：數據規模

k：“桶”的個數

In-place：占用常數內存，不占用額外內存

Out-place：占用額外內存

穩定性：排序后 2 個相等鍵值的順序和排序之前它們的順序相同

冒泡排序

冒泡排序（Bubble Sort）也是一種簡單直觀的排序算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。

算法步驟

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

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

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

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

什么時候最快

當輸入的數據已經是正序時（都已經是正序了，我還要你冒泡排序有何用啊）。

什么時候最慢

當輸入的數據是反序時（寫一個 for 循環反序輸出數據不就行了，干嘛要用你冒泡排序呢，我是閑的嗎）。

復雜程度

時間復雜度O(n^2) 空間復雜度O(1)

空間復雜度O(n^2)

動圖演示

代碼

#include <stdio.h>void bubble_sort(int a[], int size); void show(int *arr, int len);int main() {int a[7] = {1, 2, 4, 5, 3, 9, 8};//數組長度int num = sizeof(a) / sizeof(a[0]);bubble_sort(a, num);show(a, num);return 0; }void bubble_sort(int a[], int size) {for (int i = 0; i < size - 1; ++i){for (int j = 0; j < size - 1 - i; ++j){if (a[j] > a[j + 1]){int temp = a[j + 1];a[j + 1] = a[j];a[j] = temp;}}} }void show(int *arr, int len) {for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n"); }

選擇排序

選擇排序是一種簡單直觀的排序算法，無論什么數據進去都是 O(n2) 的時間復雜度。所以用到它的時候，數據規模越小越好。唯一的好處可能就是不占用額外的內存空間了吧。

算法步驟

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾。

重復第二步，直到所有元素均排序完畢。

復雜程度

時間復雜度O(n^2) 空間復雜度O(1)

空間復雜度O(1)

動圖演示

代碼

#include <stdio.h>void select_sort(int *arr, int len); void show(int *arr, int len);int main() {int drr[] = {1, 8, 7, 5, 0};//sizeof()它的作用是返回一個對象或類型所占的內存的字節數int num = sizeof(drr) / sizeof(drr[0]);select_sort(drr, num);show(drr, num);return 0; }void select_sort(int *arr, int len) {int i, j;int tmp;int min = 0;for (i = 0; i < len; i++){int min = i;for (j = i + 1; j < len; j++){if (arr[j] < arr[min]){tmp = arr[min];arr[min] = arr[j];arr[j] = tmp;}}} }void show(int *arr, int len) {for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n"); }

插入排序

插入排序（Insertion-Sort）的算法描述是一種簡單直觀的排序算法。它的工作原理是通過構建有序序列，對于未排序數據，在已排序序列中從后向前掃描，找到相應位置并插入。

算法描述

一般來說，插入排序都采用in-place在數組上實現。具體算法描述如下：

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

復雜程度

時間復雜度O(n^2) 空間復雜度O(1)

動圖演示

代碼實現

#include <stdio.h>void insertion_sort(int *arr, int size); void show(int *arr, int len);int main() {int a[7] = {1, 2, 4, 5, 3, 9, 8};//數組長度int num = sizeof(a) / sizeof(a[0]);insertion_sort(a, num);show(a, num);return 0; }void insertion_sort(int *arr, int size) {int i, j, tmp;for (i = 1; i < size; i++){if (arr[i] < arr[i - 1]){tmp = arr[i];for (j = i - 1; j >= 0 && arr[j] > tmp; j--){arr[j + 1] = arr[j];}arr[j + 1] = tmp;}} }void show(int *arr, int len) {for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n"); }

希爾排序

希爾排序（Shell Sort）
1959年Shell發明，第一個突破O(n^2)的排序算法，是簡單插入排序的改進版。它與插入排序的不同之處在于，它會優先比較距離較遠的元素。

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

希爾排序是基于插入排序的以下兩點性質而提出改進方法的：

• 插入排序在對幾乎已經排好序的數據操作時，效率高，即可以達到線性排序的效率；
• 但插入排序一般來說是低效的，因為插入排序每次只能將數據移動一位；

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

算法描述

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

• 按增量序列個數 k，對序列進行 k 趟排序；

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

復雜程度

時間復雜度O(n^1.3) 空間復雜度O(1)

代碼

#include <stdio.h>void shell_sort(int *arr, int len); void show(int *arr, int len);int main() {int drr[] = {1, 8, 7, 5, 0};//sizeof()它的作用是返回一個對象或類型所占的內存的字節數int num = sizeof(drr) / sizeof(drr[0]);shell_sort(drr, num);show(drr, num);return 0; }void shell_sort(int *arr, int size) {int i, j, tmp, increment;for (increment = size / 2; increment > 0; increment /= 2){for (i = increment; i < size; i++){tmp = arr[i];for (j = i - increment; j >= 0 && tmp < arr[j]; j -= increment){arr[j + increment] = arr[j];}arr[j + increment] = tmp;}} }void show(int *arr, int len) {for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n"); }

歸并排序

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

作為一種典型的分而治之思想的算法應用，歸并排序的實現由兩種方法：

自上而下的遞歸（所有遞歸的方法都可以用迭代重寫，所以就有了第 2 種方法）；
自下而上的迭代；
在《數據結構與算法 JavaScript 描述》中，作者給出了自下而上的迭代方法。但是對于遞歸法，作者卻認為：

However, it is not possible to do so in JavaScript, as the recursion goes too deep for the language to handle.

然而，在 JavaScript 中這種方式不太可行，因為這個算法的遞歸深度對它來講太深了。

說實話，我不太理解這句話。意思是 JavaScript 編譯器內存太小，遞歸太深容易造成內存溢出嗎？還望有大神能夠指教。

和選擇排序一樣，歸并排序的性能不受輸入數據的影響，但表現比選擇排序好的多，因為始終都是 O(nlogn) 的時間復雜度。代價是需要額外的內存空間。

算法步驟

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

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

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

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

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

復雜程度

時間復雜度O(nlog2n) 空間復雜度O(n)

動圖演示

代碼

#include <stdio.h>#define MAXSIZE 100void merge(int *list1, int list1_size, int *list2, int list2_size); void merge_sort(int k[], int n); void show(int *arr, int len);int main() {int drr[] = {1, 8, 7, 5, 0};//sizeof()它的作用是返回一個對象或類型所占的內存的字節數int num = sizeof(drr) / sizeof(drr[0]);merge_sort(drr, num);show(drr, num);return 0; }// 遞歸的方式實現歸并排序// 實現歸并，并把結果存放到list1 void merge(int *list1, int list1_size, int *list2, int list2_size) {int i, j, k, m;int temp[MAXSIZE];i = j = k = 0;while (i < list1_size && j < list2_size){if (list1[i] < list2[j]){temp[k] = list1[i];k++;i++;}else{temp[k++] = list2[j++];}}while (i < list1_size){temp[k++] = list1[i++];}while (j < list2_size){temp[k++] = list2[j++];}for (m = 0; m < (list1_size + list2_size); m++){list1[m] = temp[m];} }void merge_sort(int k[], int n) {if (n > 1){/**list1是左半部分，list2是右半部分*/int *list1 = k;int list1_size = n / 2;int *list2 = k + list1_size;int list2_size = n - list1_size;merge_sort(list1, list1_size);merge_sort(list2, list2_size);// 把兩個合在一起merge(list1, list1_size, list2, list2_size);} }void show(int *arr, int len) {for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n"); }

快速排序

快速排序（Quick Sort）
快速排序的基本思想：通過一趟排序將待排記錄分隔成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。

算法描述

快速排序使用分治法來把一個串（list）分為兩個子串（sub-lists）。具體算法描述如下：

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

復雜程度

時間復雜度O(nlog2n) 空間復雜度O(nlog2n)

動圖演示

代碼實現

#include <stdio.h>void quick_sort(int *arr, int maxlen, int begin, int end); void swap(int *a, int *b); void show(int *arr, int len);int main() {int drr[] = {1, 8, 7, 5, 0};int num = sizeof(drr) / sizeof(drr[0]);quick_sort(drr, num, 0, num - 1);show(drr, num);return 0; }void quick_sort(int *arr, int maxlen, int begin, int end) {int i, j;if (begin < end){i = begin + 1;j = end;while (i < j){if (arr[i] > arr[begin]){swap(&arr[i], &arr[j]);j--;}else{i++;}}if (arr[i] >= arr[begin]){i--;}swap(&arr[begin], &arr[i]);quick_sort(arr, maxlen, begin, i);quick_sort(arr, maxlen, j, end);} }void swap(int *a, int *b) {int temp;temp = *a;*a = *b;*b = temp; }void show(int *arr, int len) {for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n"); }

堆排序

堆排序（Heap Sort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，并同時滿足堆積的性質：即子結點的鍵值或索引總是小于（或者大于）它的父節點。

算法描述

• 將初始待排序關鍵字序列(R1,R2….Rn)構建成大頂堆，此堆為初始的無序區；
• 將堆頂元素R[1]與最后一個元素R[n]交換，此時得到新的無序區(R1,R2,……Rn-1)和新的有序區(Rn),且滿足R[1,2…n-1]<=R[n]；
• 由于交換后新的堆頂R[1]可能違反堆的性質，因此需要對當前無序區(R1,R2,……Rn-1)調整為新堆，然后再次將R[1]與無序區最后一個元素交換，得到新的無序區(R1,R2….Rn-2)和新的有序區(Rn-1,Rn)。不斷重復此過程直到有序區的元素個數為n-1，則整個排序過程完成。

復雜程度

時間復雜度O(nlog2n) 空間復雜度O(1)

動圖演示

代碼

#include <stdio.h> #include <stdlib.h>void show(int *arr, int len); void swap(int *a, int *b); void max_heapify(int arr[], int start, int end); void heap_sort(int arr[], int len);int main() {int arr[] = {1, 2, 4, 5, 3, 9, 8};int num = (int)sizeof(arr) / sizeof(*arr);heap_sort(arr, num);show(arr, num);return 0; }void swap(int *a, int *b) {int temp = *b;*b = *a;*a = temp; }void max_heapify(int arr[], int start, int end) {// 建立父節點指標和子節點指標int dad = start;int son = dad * 2 + 1;while (son <= end){ // 若子節點指標在范圍內才做比較if (son + 1 <= end && arr[son] < arr[son + 1]) // 先比較兩個子節點大小，選擇最大的son++;if (arr[dad] > arr[son]) //如果父節點大于子節點代表調整完畢，直接跳出函數return;else{ // 否則交換父子內容再繼續子節點和孫節點比較swap(&arr[dad], &arr[son]);dad = son;son = dad * 2 + 1;}} }void heap_sort(int arr[], int len) {int i;// 初始化，i從最后一個父節點開始調整for (i = len / 2 - 1; i >= 0; i--)max_heapify(arr, i, len - 1);// 先將第一個元素和已排好元素前一位做交換，再重新調整，直到排序完畢for (i = len - 1; i > 0; i--){swap(&arr[0], &arr[i]);max_heapify(arr, 0, i - 1);} }void show(int *arr, int len) {for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n"); }

計數排序

計數排序（Counting Sort）
計數排序不是基于比較的排序算法，其核心在于將輸入的數據值轉化為鍵存儲在額外開辟的數組空間中。 作為一種線性時間復雜度的排序，計數排序要求輸入的數據必須是有確定范圍的整數。

算法描述

• 找出待排序的數組中最大和最小的元素；
• 統計數組中每個值為i的元素出現的次數，存入數組C的第i項；
• 對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）；
• 反向填充目標數組：將每個元素i放在新數組的第C(i)項，每放一個元素就將C(i)減去1。

復雜程度

時間復雜度O(n+k) 空間復雜度O(n+k)

動圖演示

代碼

#include <stdio.h> #include <assert.h> #include <stdlib.h>void count_sort(int *a, int len); void show(int *arr, int len);int main() {int a[] = {3, 4, 3, 2, 1, 2, 6, 5, 4, 7};printf("排序前：");show(a, sizeof(a) / sizeof(int));count_sort(a, sizeof(a) / sizeof(int));printf("排序后：");show(a, sizeof(a) / sizeof(int));return 0; }//計數排序 void count_sort(int *a, int len) {assert(a);//通過max和min計算出臨時數組所需要開辟的空間大小int max = a[0], min = a[0];for (int i = 0; i < len; i++){if (a[i] > max)max = a[i];if (a[i] < min)min = a[i];}//使用calloc將數組都初始化為0int range = max - min + 1;int *b = (int *)calloc(range, sizeof(int));//使用臨時數組記錄原始數組中每個數的個數for (int i = 0; i < len; i++){//注意：這里在存儲上要在原始數組數值上減去min才不會出現越界問題b[a[i] - min] += 1;}int j = 0;//根據統計結果，重新對元素進行回收for (int i = 0; i < range; i++){while (b[i]--){//注意：要將i的值加上min才能還原到原始數據a[j++] = i + min;}}//釋放臨時數組free(b);b = NULL; }void show(int *arr, int len) {for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n"); }

桶排序

桶排序（Bucket Sort）
桶排序是計數排序的升級版。它利用了函數的映射關系，高效與否的關鍵就在于這個映射函數的確定。桶排序 (Bucket sort)的工作的原理：假設輸入數據服從均勻分布，將數據分到有限數量的桶里，每個桶再分別排序（有可能再使用別的排序算法或是以遞歸方式繼續使用桶排序進行排）。

算法描述

• 設置一個定量的數組當作空桶；
• 遍歷輸入數據，并且把數據一個一個放到對應的桶里去；
• 對每個不是空的桶進行排序；
• 從不是空的桶里把排好序的數據拼接起來。

復雜程度

時間復雜度O(n+k) 空間復雜度O(n+k)

代碼

#include <iostream> #include <stdio.h>void bucket_sort(int *arr, int size, int max); void show(int *arr, int len);int main() {int a[7] = {1, 2, 4, 5, 3, 9, 8};//數組長度int num = sizeof(a) / sizeof(a[0]);bucket_sort(a, num, num);show(a, num);return 0; }void bucket_sort(int *arr, int size, int max) {int i, j;int buckets[max];memset(buckets, 0, max * sizeof(int));for (i = 0; i < size; i++){buckets[arr[i]]++;}for (i = 0, j = 0; i < max; i++){while ((buckets[i]--) > 0)arr[j++] = i;} }void show(int *arr, int len) {for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n"); }

基數排序

基數排序（Radix Sort）
基數排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次類推，直到最高位。有時候有些屬性是有優先級順序的，先按低優先級排序，再按高優先級排序。最后的次序就是高優先級高的在前，高優先級相同的低優先級高的在前。

算法描述

• 取得數組中的最大數，并取得位數；
• arr為原始數組，從最低位開始取每個位組成radix數組；
• 對radix進行計數排序（利用計數排序適用于小范圍數的特點）；

復雜程度

時間復雜度O(n*k) 空間復雜度O(n+k)

代碼

#include <stdio.h> #include <string.h> #define N 10 //數組長度 #define D 10 //最大位數void show(int *arr, int len); int get_digit(int M, int i); void radix_sort(int num[], int len);int main() {int a[7] = {1, 2, 4, 5, 3, 9, 8};//數組長度int num = sizeof(a) / sizeof(*a);radix_sort(a, num);show(a, num);return 0; }int get_digit(int M, int i) //取整數M的第i位數 {while (i > 1){M /= 10;i--;}return M % 10; }void radix_sort(int num[], int len) {int i, j, k, l, digit;int allot[10][N]; //《分配數組》memset(allot, 0, sizeof(allot)); //初始化《分配數組》for (i = 1; i <= D; i++){int flag = 0;//分配相應位數的數據，并存入《分配數組》for (j = 0; j < len; j++){digit = get_digit(num[j], i);k = 0;while (allot[digit][k])k++;allot[digit][k] = num[j];if (digit) //判斷是否達到了最高位數flag = 1;}if (!flag) //如果數組每個數的第i位都為零break; //即可直接退出循環//將《分配數組》的數據依次收集到原數組中l = 0;for (j = 0; j < 10; j++){k = 0;while (allot[j][k] > 0){num[l++] = allot[j][k];k++;}}//每次分配，收集后初始化《分配數組》，用于下一位數的分配和收集memset(allot, 0, sizeof(allot));} }void show(int *arr, int len) {for (int i = 0; i < len; i++){printf("%d ", arr[i]);}printf("\n"); }

總結

以上是生活随笔為你收集整理的C 数据结构之十大排序的全部內容，希望文章能夠幫你解決所遇到的問題。

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