七大經典排序算法圖解
插入排序
①直接插入排序
基本思想
每次從一個有序序列開始,將待排元素與有序序列中的元素從後往前逐個比較,
若有序序列中的元素大於待排元素,則將較大的元素往後覆蓋;
否則,將待排元素插入其前面,並結束此輪比較。
動圖演示
代碼實現
void InsertSort(int* a, int n) { for (int i = 0; i < n - 1; i++) { int end = i; int x = a[end + 1]; while (end >= 0) { if (a[end] > x) { a[end + 1] = a[end]; end--; } else break; } a[end + 1] = x; } }
②希爾排序
基本思想
先選定一個整數作為 gap ,將待排序列以 gap 為間隔分成 gap 組,
先對每組進行直接插入排序,
然後再適當縮小 gap ,重復上述步驟。
當 gap = 1 時,此時序列已經進行瞭多次預排序,接近有序。
這時再對序列進行直接插入排序,就能達到優化的效果。
圖示
代碼實現
void ShellSort(int* a, int n) { //多次預排序(gap > 1) + 直接插入( gap == 1) int gap = n; while (gap > 1) { //使gap最後一次一定能到1 gap = gap / 3 + 1; //多組一起排 for (int i = 0; i < n - gap; ++i) { int end = i; int x = a[end + gap]; while (end >= 0) { if (a[end] > x) { a[end + gap] = a[end]; end -= gap; } else break; } a[end + gap] = x; } } }
選擇排序
③直接選擇排序
基本思想
每一次從待排序的數據元素中選出最小(或最大)的一個元素,存放在序列的起始(末尾)位置,直到全部待排序的數據元素排完 。
動圖演示
以每次選出最小值為例
代碼實現
void Swap(int* px, int* py) { int tmp = *px; *px = *py; *py = tmp; } void SelectSort(int* a, int n) { int begin = 0; while (begin < n - 1) { int mini = begin; for (int i = begin; i < n; i++) { if (a[i] < a[mini]) mini = i; } Swap(&a[begin], &a[mini]); ++begin; } }
④堆排序
基本思想
小堆根上的元素是堆中最小的元素,大堆根上的元素是堆中最大的元素。
先將待排序列建成小(大)堆,
獲取堆根上的元素,這樣就達到瞭選出待排序列中最小(大)元素的目的,
然後再將其放至正確位置。
建堆需要註意的問題
若將待排序列建成小堆,則每次可將待排序列中最小的元素放至正確的位置,但每次排除堆根後,剩下元素組成的堆結構被打亂,需要對剩下待排序列重新建堆,反而增加的問題的復雜性。
故我們將其建成大堆,每次將堆根上的元素(待排序列中最大的元素)與待排序列中最後一個元素進行交換,將大堆根上的元素換至正確位置,然後再使用向下調整算法,將交換上來的元素調整至一個大堆中的合適位置。
圖示
代碼實現
void Swap(int* px, int* py) { int tmp = *px; *px = *py; *py = tmp; } //建大堆的向下調整算法 void AdjustDown(int* a, int n, int parent) { int child = parent * 2 + 1; while (child < n) { if (child + 1 < n && a[child + 1] > a[child]) ++child; if (a[child] > a[parent]) { Swap(&a[child], &a[parent]); parent = child; child = parent * 2 + 1; } else break; } } void HeapSort(int* a, int n) { //先使用向下調整算法,從最後一個元素的父親開始建堆 for (int i = (n - 1 - 1) / 2; i >= 0; --i) { AdjustDown(a, n, i); } //先交換,再調整 for (int end = n - 1; end > 0; --end) { Swap(&a[0], &a[end]); AdjustDown(a, end, 0); } }
交換排序
⑤冒泡排序
基本思想
從待排序列的首元素開始,從前往後依次進行比較,
若大於則交換,將其繼續與後面元素比較,直到被放至正確位置。
否則迭代至與其比較的元素,重復上面的步驟。
動圖演示
代碼實現
void Swap(int* px, int* py) { int tmp = *px; *px = *py; *py = tmp; } void BubbleSort(int* a, int n) { for (int j = 0; j < n; j++) { for (int i = 0; i < n - j - 1; i++) { if (a[i] > a[i + 1]) { Swap(&a[i], &a[i + 1]); } } } }
⑥快速排序
基本思想
任取待排序元素序列中的某元素作為基準值,按照該排序碼將待排序集合分割成兩子序列,左子序列中所有元素均小於基準值,右子序列中所有元素均大於基準值,然後最左右子序列重復該過程,直到所有元素都排列在相應位置上為止。
基本框架
void QuickSort(int* a, int left, int right) { if (left >= right) return; //先將選定的基準值排好 int keyi = Partion(a, left, right); //再通過遞歸排序其左右子序列 QuickSort(a, left, keyi - 1); QuickSort(a, keyi + 1, right); }
Partion函數分析
Partion函數在這裡的作用是:
將選定的基準值排到正確位置,並將待排序列分成比基準值小的左子序列,比基準值大的右子序列。
將區間按照基準值劃分為左右兩半部分的常見方式有:
1.hoare版本
基本思想:
選擇待排序列的最左值的下標為基準值所指下標,當區間左下標小於區間右下標時,先從右開始找比基準值小的值,找到後再從左開始找比基準值大的值,都找到後,將左右下標對應的值交換,然後從右開始重復上述步驟,直到左右下標相等。當左右下標相等時,將下標所指向的值與基準值互換。
動圖演示:
代碼實現:
//hoare版本 int Partion(int* a, int left, int right) { int keyi = left; while (left < right) { //右邊先走,找小 while (left < right && a[right] >= a[keyi]) { --right; } //左邊走,找大 while (left < right && a[left] <= a[keyi]) { ++left; } Swap(&a[left], &a[right]); } Swap(&a[keyi], &a[left]); return left; }
2.挖坑法
基本思想:
選擇待排序列的最左值為基準值,將其下標記為坑的下標。當區間左下標小於區間右下標時,先從右開始找比基準值小的值,找到後將其放在當前坑上,並將坑替換到所找位置。再從左開始找比基準值大的值,找到後同樣將其放在當前坑上,然後從右開始重復上述步驟,直到左右下標相等。當左右下標相等時,把基準值放到當前坑所在位置。
動圖演示:
代碼實現:
//挖坑法 int Partion(int* a, int left, int right) { int key = a[left]; int pivot = left; while (left < right) { //右邊先走,找小 while (left < right && a[right] >= key) { --right; } //值覆蓋,坑替換 a[pivot] = a[right]; pivot = right; //左邊走,找大 while (left < right && a[left] <= key) { ++left; } //值覆蓋,坑替換 a[pivot] = a[left]; pivot = left; } a[pivot] = key; return pivot; }
3.前後指針法
基本思想:
選擇最左值的下標為基準值下標,並設定指向前後位置的兩個下標 cur , prev 。使 prev 指向基準值的位置,cur 指向基準值的前一個位置。當 cur <= right,也就是 cur 指向的位置小於等於右區間的位置時,從 cur 開始找比基準值小的值,並將其與 prev 所在位置的前一個交換。當 cur 跳出右區間時,將基準值與 prev 所指向的值交換。
動圖演示:
代碼實現:
//前後指針法 ——更推薦 int Partion(int* a, int left, int right) { int keyi = left; int cur = left + 1; int prev = left; while (cur <= right) { //cur找小,把小的換到左邊 if (a[cur] < a[keyi]) { ++prev; Swap(&a[cur], &a[prev]); } ++cur; } Swap(&a[prev], &a[keyi]); return prev; }
小結:
hoare版本與挖坑法都需要註意,不管是從右開始找還是從左開始找,始終都要註意左下標要小於右下標,若沒有此限定條件,當從任一方向開始找值時,一旦沒有找到我們所預想的值,就會導致越界情況產生。
而前後指針法是從一個方向開始,遍歷搜索一次待排序列,隻需設定一次限定條件。
故這裡更推薦使用前後指針法來實現快速排序。
Partion函數的優化
由於每次是以基準值為準,將待排序列分成左右兩個子序列,若每次能保證選到的基準值的正確位置在待排序列的中間部分,則每次分序列時,都能大致將待排序列分成均衡的兩部分,從而將排序次數減少。
這裡使用到三數取中的方法:
再排序前,先將最左值、中間值與最右值進行比較,選出三個數中的中間值,並將其與最左值交換,這樣每次以最左值為基準值時,都能選到一個大致在中間部分的數。
代碼:
//三數取中 int GetMidIndex(int* a, int left, int right) { int mid = (left + right) / 2; if (a[left] > a[mid]) { if (a[mid] > a[right]) return mid; else if (a[left] < a[right]) return left; else return right; } else { if (a[mid] < a[right]) return mid; else if (a[left] > a[right]) return left; else return right; } }
快速排序代碼實現
//三數取中 int GetMidIndex(int* a, int left, int right) { //int mid = (left + right) / 2; int mid = left + ((right - left) >> 1); if (a[left] > a[mid]) { if (a[mid] > a[right]) return mid; else if (a[left] < a[right]) return left; else return right; } else { if (a[mid] < a[right]) return mid; else if (a[left] > a[right]) return left; else return right; } } void Swap(int* px, int* py) { int tmp = *px; *px = *py; *py = tmp; } //前後指針法 int Partion(int* a, int left, int right) { int midi = GetMidIndex(a, left, right); Swap(&a[midi], &a[left]); int keyi = left; int cur = left + 1; int prev = left; while (cur <= right) { //cur找小,把小的換到左邊 if (a[cur] < a[keyi] && ++prev != cur) { Swap(&a[cur], &a[prev]); } ++cur; } Swap(&a[prev], &a[keyi]); return prev; } void QuickSort(int* a, int left, int right) { if (left >= right) return; int keyi = Partion3(a, left, right); QuickSort(a, left, keyi - 1); QuickSort(a, keyi + 1, right); }
歸並排序
⑦歸並排序
基本思想
歸並排序是將待排序列先分解至單個子序列,再將已有序的子序列合並一個臨時數組中,得到完全有序的序列後再拷貝回原數組。即先使左右子序列有序,再將其歸並為一個完整的有序序列。
動圖演示
代碼實現
void _MergeSort(int* a, int left, int right, int* tmp) { if (left >= right) return; int mid = left + ((right - left) >> 1); _MergeSort(a, left, mid, tmp); _MergeSort(a, mid + 1, right, tmp); //歸並 int begin1 = left, end1 = mid; int begin2 = mid + 1, end2 = right; int i = left; while (begin1 <= end1 && begin2 <= end2) { if (a[begin1] <= a[begin2]) { tmp[i++] = a[begin1++]; } else { tmp[i++] = a[begin2++]; } } while (begin1 <= end1) { tmp[i++] = a[begin1++]; } while (begin2 <= end2) { tmp[i++] = a[begin2++]; } //把排序後的元素拷貝回原來的數組 for (int j = left; j <= right; ++j) { a[j] = tmp[j]; } } void MergeSort(int* a, int n) { int* tmp = (int*)malloc(sizeof(int) * n); if (tmp == NULL) { printf("malloc fail\n"); exit(-1); } _MergeSort(a, 0, n - 1, tmp); free(tmp); tmp = NULL; }
排序算法復雜度及穩定性分析
以上所述是小編給大傢介紹的七大經典排序算法圖解,希望對大傢有所幫助。在此也非常感謝大傢對WalkonNet網站的支持!