插入排序
①直接插入排序
基本思想
每次從一個有序序列開始，將待排元素與有序序列中的元素從后往前逐個比較，
若有序序列中的元素大于待排元素，則將較大的元素往后覆蓋；
否則，將待排元素插入其前面，并結(jié)束此輪比較。
動圖演示
?
代碼實現(xiàn)
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;
}
}
②希爾排序
基本思想
先選定一個整數(shù)作為 gap ,將待排序列以 gap 為間隔分成 gap 組，
先對每組進行直接插入排序，
然后再適當(dāng)縮小 gap ,重復(fù)上述步驟。
當(dāng) gap = 1 時，此時序列已經(jīng)進行了多次預(yù)排序，接近有序。
這時再對序列進行直接插入排序，就能達到優(yōu)化的效果。
圖示
?
代碼實現(xiàn)
void ShellSort(int* a, int n)
{
//多次預(yù)排序(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;
}
}
}
選擇排序
③直接選擇排序
基本思想
每一次從待排序的數(shù)據(jù)元素中選出最小(或最大)的一個元素，存放在序列的起始(末尾)位置，直到全部待排序的數(shù)據(jù)元素排完 。
動圖演示
以每次選出最小值為例
代碼實現(xiàn)
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;
}
}
④堆排序
基本思想
小堆根上的元素是堆中最小的元素，大堆根上的元素是堆中最大的元素。
先將待排序列建成小(大)堆，
獲取堆根上的元素，這樣就達到了選出待排序列中最小(大)元素的目的，
然后再將其放至正確位置。
建堆需要注意的問題
若將待排序列建成小堆，則每次可將待排序列中最小的元素放至正確的位置，但每次排除堆根后，剩下元素組成的堆結(jié)構(gòu)被打亂，需要對剩下待排序列重新建堆，反而增加的問題的復(fù)雜性。
故我們將其建成大堆，每次將堆根上的元素(待排序列中最大的元素)與待排序列中最后一個元素進行交換，將大堆根上的元素?fù)Q至正確位置，然后再使用向下調(diào)整算法，將交換上來的元素調(diào)整至一個大堆中的合適位置。
圖示
代碼實現(xiàn)
void Swap(int* px, int* py)
{
int tmp = *px;
*px = *py;
*py = tmp;
}
//建大堆的向下調(diào)整算法
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)
{
//先使用向下調(diào)整算法，從最后一個元素的父親開始建堆
for (int i = (n - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(a, n, i);
}
//先交換，再調(diào)整
for (int end = n - 1; end > 0; --end)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
}
}
交換排序
⑤冒泡排序
基本思想
從待排序列的首元素開始，從前往后依次進行比較，
若大于則交換，將其繼續(xù)與后面元素比較，直到被放至正確位置。
否則迭代至與其比較的元素，重復(fù)上面的步驟。
動圖演示
代碼實現(xiàn)
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]);
}
}
}
}
⑥快速排序
基本思想
任取待排序元素序列中的某元素作為基準(zhǔn)值，按照該排序碼將待排序集合分割成兩子序列，左子序列中所有元素均小于基準(zhǔn)值，右子序列中所有元素均大于基準(zhǔn)值，然后最左右子序列重復(fù)該過程，直到所有元素都排列在相應(yīng)位置上為止。
基本框架
void QuickSort(int* a, int left, int right)
{
if (left >= right)
return;
//先將選定的基準(zhǔn)值排好
int keyi = Partion(a, left, right);
//再通過遞歸排序其左右子序列
QuickSort(a, left, keyi - 1);
QuickSort(a, keyi + 1, right);
}
Partion函數(shù)分析
Partion函數(shù)在這里的作用是：
將選定的基準(zhǔn)值排到正確位置，并將待排序列分成比基準(zhǔn)值小的左子序列，比基準(zhǔn)值大的右子序列。
將區(qū)間按照基準(zhǔn)值劃分為左右兩半部分的常見方式有：
1.hoare版本
基本思想：
選擇待排序列的最左值的下標(biāo)為基準(zhǔn)值所指下標(biāo)，當(dāng)區(qū)間左下標(biāo)小于區(qū)間右下標(biāo)時，先從右開始找比基準(zhǔn)值小的值，找到后再從左開始找比基準(zhǔn)值大的值，都找到后，將左右下標(biāo)對應(yīng)的值交換，然后從右開始重復(fù)上述步驟，直到左右下標(biāo)相等。當(dāng)左右下標(biāo)相等時，將下標(biāo)所指向的值與基準(zhǔn)值互換。
動圖演示：
代碼實現(xiàn)：
//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.挖坑法
基本思想：
選擇待排序列的最左值為基準(zhǔn)值，將其下標(biāo)記為坑的下標(biāo)。當(dāng)區(qū)間左下標(biāo)小于區(qū)間右下標(biāo)時，先從右開始找比基準(zhǔn)值小的值，找到后將其放在當(dāng)前坑上，并將坑替換到所找位置。再從左開始找比基準(zhǔn)值大的值，找到后同樣將其放在當(dāng)前坑上，然后從右開始重復(fù)上述步驟，直到左右下標(biāo)相等。當(dāng)左右下標(biāo)相等時，把基準(zhǔn)值放到當(dāng)前坑所在位置。
動圖演示：
代碼實現(xiàn)：
//挖坑法
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.前后指針法
基本思想：
選擇最左值的下標(biāo)為基準(zhǔn)值下標(biāo)，并設(shè)定指向前后位置的兩個下標(biāo) cur , prev 。使 prev 指向基準(zhǔn)值的位置，cur 指向基準(zhǔn)值的前一個位置。當(dāng) cur <= right,也就是 cur 指向的位置小于等于右區(qū)間的位置時，從 cur 開始找比基準(zhǔn)值小的值，并將其與 prev 所在位置的前一個交換。當(dāng) cur 跳出右區(qū)間時，將基準(zhǔn)值與 prev 所指向的值交換。
動圖演示：
代碼實現(xiàn)：
//前后指針法 ——更推薦
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;
}
小結(jié)：
hoare版本與挖坑法都需要注意，不管是從右開始找還是從左開始找，始終都要注意左下標(biāo)要小于右下標(biāo)，若沒有此限定條件，當(dāng)從任一方向開始找值時，一旦沒有找到我們所預(yù)想的值，就會導(dǎo)致越界情況產(chǎn)生。
而前后指針法是從一個方向開始，遍歷搜索一次待排序列，只需設(shè)定一次限定條件。
故這里更推薦使用前后指針法來實現(xiàn)快速排序。
Partion函數(shù)的優(yōu)化
由于每次是以基準(zhǔn)值為準(zhǔn)，將待排序列分成左右兩個子序列，若每次能保證選到的基準(zhǔn)值的正確位置在待排序列的中間部分，則每次分序列時，都能大致將待排序列分成均衡的兩部分，從而將排序次數(shù)減少。
這里使用到三數(shù)取中的方法：
再排序前，先將最左值、中間值與最右值進行比較，選出三個數(shù)中的中間值，并將其與最左值交換，這樣每次以最左值為基準(zhǔn)值時，都能選到一個大致在中間部分的數(shù)。
代碼：
//三數(shù)取中
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;
}
}
快速排序代碼實現(xiàn)
//三數(shù)取中
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);
}
歸并排序
⑦歸并排序
基本思想
歸并排序是將待排序列先分解至單個子序列，再將已有序的子序列合并一個臨時數(shù)組中，得到完全有序的序列后再拷貝回原數(shù)組。即先使左右子序列有序，再將其歸并為一個完整的有序序列。
動圖演示
代碼實現(xiàn)
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++];
}
//把排序后的元素拷貝回原來的數(shù)組
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;
}
排序算法復(fù)雜度及穩(wěn)定性分析
以上所述是小編給大家介紹的七大經(jīng)典排序算法圖解，希望對大家有所幫助。在此也非常感謝大家對服務(wù)器之家網(wǎng)站的支持！
原文鏈接：https://blog.csdn.net/weixin_60954394/article/details/121431922
