七大經典排序算法圖解
插入排序
①直接插入排序
基本思想
每次從一個有序序列開始，將待排元素與有序序列中的元素從后往前逐個比較，
若有序序列中的元素大于待排元素，則將較大的元素往后覆蓋；
否則，將待排元素插入其前面，并結束此輪比較。
動圖演示
?
代碼實現
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 時，此時序列已經進行了多次預排序，接近有序。
這時再對序列進行直接插入排序，就能達到優(yōu)化的效果。
圖示
?
代碼實現
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);
}
}
交換排序
⑤冒泡排序
基本思想
從待排序列的首元素開始，從前往后依次進行比較，
若大于則交換，將其繼續(xù)與后面元素比較，直到被放至正確位置。
否則迭代至與其比較的元素，重復上面的步驟。
動圖演示
代碼實現
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函數在這里的作用是：
將選定的基準值排到正確位置，并將待排序列分成比基準值小的左子序列，比基準值大的右子序列。
將區(qū)間按照基準值劃分為左右兩半部分的常見方式有：
1.hoare版本
基本思想：
選擇待排序列的最左值的下標為基準值所指下標，當區(qū)間左下標小于區(qū)間右下標時，先從右開始找比基準值小的值，找到后再從左開始找比基準值大的值，都找到后，將左右下標對應的值交換，然后從右開始重復上述步驟，直到左右下標相等。當左右下標相等時，將下標所指向的值與基準值互換。
動圖演示：
代碼實現：
//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.挖坑法
基本思想：
選擇待排序列的最左值為基準值，將其下標記為坑的下標。當區(qū)間左下標小于區(qū)間右下標時，先從右開始找比基準值小的值，找到后將其放在當前坑上，并將坑替換到所找位置。再從左開始找比基準值大的值，找到后同樣將其放在當前坑上，然后從右開始重復上述步驟，直到左右下標相等。當左右下標相等時，把基準值放到當前坑所在位置。
動圖演示：
代碼實現：
//挖坑法
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 指向的位置小于等于右區(qū)間的位置時，從?cur 開始找比基準值小的值，并將其與 prev 所在位置的前一個交換。當 cur 跳出右區(qū)間時，將基準值與 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函數的優(yōu)化
由于每次是以基準值為準，將待排序列分成左右兩個子序列，若每次能保證選到的基準值的正確位置在待排序列的中間部分，則每次分序列時，都能大致將待排序列分成均衡的兩部分，從而將排序次數減少。
這里使用到三數取中的方法：
再排序前，先將最左值、中間值與最右值進行比較，選出三個數中的中間值，并將其與最左值交換，這樣每次以最左值為基準值時，都能選到一個大致在中間部分的數。
代碼：
//三數取中
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;
}
排序算法復雜度及穩(wěn)定性分析
以上所述是小編給大家介紹的七大經典排序算法圖解，希望對大家有所幫助。在此也非常感謝大家對腳本之家網站的支持！
相關文章
這篇文章主要為大家詳細介紹了C語言數字圖像處理之圖像縮放，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-10-10
C++實現LeetCode(157.用Read4來讀取N個字符)
這篇文章主要介紹了C++實現LeetCode(157.用Read4來讀取N個字符),本篇文章通過簡要的案例,講解了該項技術的了解與使用,以下就是詳細內容,需要的朋友可以參考下2021-07-07
這篇文章主要介紹了C/C++?單元自動化測試解決方案總結，通過利用GCC插件來實現提升C/C++開發(fā)者的單元效率工具解決方案，希望對大家在提升單元測試效率上有所啟發(fā)2022-06-06
在本文里小編給大家分享的是關于c語言的注釋定界符知識點詳解，需要的朋友們可以跟著學習下。2020-02-02
以下是對C/C++中的SIZEOF進行了詳細的分析介紹，需要的朋友參考下2013-07-07
這篇文章主要介紹了C++中對構造函數和賦值運算符的復制和移動,是C++入門學習中的基礎知識,需要的朋友可以參考下2016-01-01
Qt中QImage類封裝了對于一般圖像像素級的操作,圖像顯示則使用QPixmap,本文主要介紹了Qt QImage和QPixmap使用與區(qū)別,具有一定的參考價值,感興趣的可以了解一下2024-03-03
Visual Studio Code (vscode) 配置 C / C++ 環(huán)境的流程
這篇文章主要介紹了Visual Studio Code (vscode) 配置 C / C++ 環(huán)境的流程，本文通過實例代碼給大家介紹的非常詳細，具有一定的參考借鑒價值,需要的朋友可以參考下2019-09-09
這篇文章主要介紹了C++高級數據結構之線段樹，文章圍繞主題的相關資料展開詳細的內容介紹，具有一定的參考價值，需要的小伙伴可以參考一下2022-05-05
trait模板和policy模板技術是把模板的trait和policy這兩個針對不同具體類型有變化的方面抽離出來形成兩個獨立的模板。由于trait和policy本身是模板，它的行為是可配置的，在模板中通過組合或者以模板實參傳進來的方式使用trait和policy，就可以配置出不同的具體實現2021-06-06