1. 插入排序
步驟：
1.從第一個(gè)元素開(kāi)始，該元素可以認(rèn)為已經(jīng)被排序
2.取下一個(gè)元素tem，從已排序的元素序列從后往前掃描
3.如果該元素大于tem，則將該元素移到下一位
4.重復(fù)步驟3，直到找到已排序元素中小于等于tem的元素
5.tem插入到該元素的后面，如果已排序所有元素都大于tem，則將tem插入到下標(biāo)為0的位置
6.重復(fù)步驟2~5
動(dòng)圖演示如下：
思路：
在待排序的元素中，假設(shè)前n-1個(gè)元素已有序，現(xiàn)將第n個(gè)元素插入到前面已經(jīng)排好的序列中，使得前n個(gè)元素有序。按照此法對(duì)所有元素進(jìn)行插入，直到整個(gè)序列有序。
但我們并不能確定待排元素中究竟哪一部分是有序的，所以我們一開(kāi)始只能認(rèn)為第一個(gè)元素是有序的，依次將其后面的元素插入到這個(gè)有序序列中來(lái)，直到整個(gè)序列有序?yàn)橹埂?/p>
代碼如下：
void InsertSort(int* arr, int n)
{
for (int i = 0; i < n - 1; ++i)
{
//記錄有序序列最后一個(gè)元素的下標(biāo)
int end = i;
//待插入的元素
int tem = arr[end + 1];
//單趟排
while (end >= 0)
{
//比插入的數(shù)大就向后移
if (tem < arr[end])
{
arr[end + 1] = arr[end];
end--;
}
//比插入的數(shù)小，跳出循環(huán)
else
{
break;
}
}
//tem放到比插入的數(shù)小的數(shù)的后面
arr[end + 1] = tem;
//代碼執(zhí)行到此位置有兩種情況:
//1.待插入元素找到應(yīng)插入位置（break跳出循環(huán)到此）
//2.待插入元素比當(dāng)前有序序列中的所有元素都小（while循環(huán)結(jié)束后到此）
}
}
時(shí)間復(fù)雜度：最壞情況下為O(N*N)，此時(shí)待排序列為逆序，或者說(shuō)接近逆序
最好情況下為O(N)，此時(shí)待排序列為升序，或者說(shuō)接近升序。
空間復(fù)雜度：O(1)
2.希爾排序
步驟：
1.先選定一個(gè)小于N的整數(shù)gap作為第一增量，然后將所有距離為gap的元素分在同一組，并對(duì)每一組的元素進(jìn)行直接插入排序。然后再取一個(gè)比第一增量小的整數(shù)作為第二增量，重復(fù)上述操作…
2.當(dāng)增量的大小減到1時(shí)，就相當(dāng)于整個(gè)序列被分到一組，進(jìn)行一次直接插入排序，排序完成。
動(dòng)圖如下：
思路：
希爾排序，先將待排序列進(jìn)行預(yù)排序，使待排序列接近有序，然后再對(duì)該序列進(jìn)行一次插入排序，此時(shí)插入排序的時(shí)間復(fù)雜度為O(N)，
代碼如下：
//希爾排序
void ShellSort(int* arr, int n)
{
int gap = n;
while (gap>1)
{
//每次對(duì)gap折半操作
gap = gap / 2;
//單趟排序
for (int i = 0; i < n - gap; ++i)
{
int end = i;
int tem = arr[end + gap];
while (end >= 0)
{
if (tem < arr[end])
{
arr[end + gap] = arr[end];
end -= gap;
}
else
{
break;
}
}
arr[end + gap] = tem;
}
}
}
時(shí)間復(fù)雜度平均：O(N^1.3)
空間復(fù)雜度：O(1)
3.選擇排序
思路：
每次從待排序列中選出一個(gè)最小值，然后放在序列的起始位置，直到全部待排數(shù)據(jù)排完即可。
實(shí)際上，我們可以一趟選出兩個(gè)值，一個(gè)最大值一個(gè)最小值，然后將其放在序列開(kāi)頭和末尾，這樣可以使選擇排序的效率快一倍。
動(dòng)圖如下：
代碼如下：
//選擇排序
void swap(int* a, int* b)
{
int tem = *a;
*a = *b;
*b = tem;
}
void SelectSort(int* arr, int n)
{
//保存參與單趟排序的第一個(gè)數(shù)和最后一個(gè)數(shù)的下標(biāo)
int begin = 0, end = n - 1;
while (begin < end)
{
//保存最大值的下標(biāo)
int maxi = begin;
//保存最小值的下標(biāo)
int mini = begin;
//找出最大值和最小值的下標(biāo)
for (int i = begin; i <= end; ++i)
{
if (arr[i] < arr[mini])
{
mini = i;
}
if (arr[i] > arr[maxi])
{
maxi = i;
}
}
//最小值放在序列開(kāi)頭
swap(&arr[mini], &arr[begin]);
//防止最大的數(shù)在begin位置被換走
if (begin == maxi)
{
maxi = mini;
}
//最大值放在序列結(jié)尾
swap(&arr[maxi], &arr[end]);
++begin;
--end;
}
}
時(shí)間復(fù)雜度：最壞情況：O(N^2)
最好情況：O(N^2)
空間復(fù)雜度：O(1)
4.冒泡排序
思路：
左邊大于右邊交換一趟排下來(lái)最大的在右邊
動(dòng)圖如下：
代碼如下：
//冒泡排序
void BubbleSort(int* arr, int n)
{
int end = n;
while (end)
{
int flag = 0;
for (int i = 1; i < end; ++i)
{
if (arr[i - 1] > arr[i])
{
int tem = arr[i];
arr[i] = arr[i - 1];
arr[i - 1] = tem;
flag = 1;
}
}
if (flag == 0)
{
break;
}
--end;
}
}
時(shí)間復(fù)雜度：最壞情況：O(N^2)
最好情況：O(N)
空間復(fù)雜度：O(1)
5.堆排序
堆排可看之間這篇博文----->[堆排]
6.快速排序
6.1 hoare版本(左右指針?lè)?
思路：
1、選出一個(gè)key，一般是最左邊或是最右邊的。
2、定義一個(gè)begin和一個(gè)end，begin從左向右走，end從右向左走。（需要注意的是：若選擇最左邊的數(shù)據(jù)作為key，則需要end先走；若選擇最右邊的數(shù)據(jù)作為key，則需要bengin先走）。
3、在走的過(guò)程中，若end遇到小于key的數(shù)，則停下，begin開(kāi)始走，直到begin遇到一個(gè)大于key的數(shù)時(shí)，將begin和right的內(nèi)容交換，end再次開(kāi)始走，如此進(jìn)行下去，直到begin和end最終相遇，此時(shí)將相遇點(diǎn)的內(nèi)容與key交換即可。（選取最左邊的值作為key）
4.此時(shí)key的左邊都是小于key的數(shù)，key的右邊都是大于key的數(shù)
5.將key的左序列和右序列再次進(jìn)行這種單趟排序，如此反復(fù)操作下去，直到左右序列只有一個(gè)數(shù)據(jù)，或是左右序列不存在時(shí)，便停止操作，此時(shí)此部分已有序
單趟動(dòng)圖如下：
代碼如下：
//快速排序 hoare版本(左右指針?lè)?
void QuickSort(int* arr, int begin, int end)
{
//只有一個(gè)數(shù)或區(qū)間不存在
if (begin >= end)
return;
int left = begin;
int right = end;
//選左邊為key
int keyi = begin;
while (begin < end)
{
//右邊選小 等號(hào)防止和key值相等 防止順序begin和end越界
while (arr[end] >= arr[keyi] && begin < end)
{
--end;
}
//左邊選大
while (arr[begin] <= arr[keyi] && begin < end)
{
++begin;
}
//小的換到右邊，大的換到左邊
swap(&arr[begin], &arr[end]);
}
swap(&arr[keyi], &arr[end]);
keyi = end;
//[left,keyi-1]keyi[keyi+1,right]
QuickSort(arr, left, keyi - 1);
QuickSort(arr,keyi + 1,right);
}
時(shí)間復(fù)雜度:
快速排序的過(guò)程類似于二叉樹(shù)其高度為logN，每層約有N個(gè)數(shù)，如下圖所示：
6.2 挖坑法
思路：
挖坑法思路與hoare版本(左右指針?lè)?思路類似
1.選出一個(gè)數(shù)據(jù)（一般是最左邊或是最右邊的）存放在key變量中，在該數(shù)據(jù)位置形成一個(gè)坑
2、還是定義一個(gè)L和一個(gè)R，L從左向右走，R從右向左走。（若在最左邊挖坑，則需要R先走；若在最右邊挖坑，則需要L先走）
后面的思路與hoare版本(左右指針?lè)?思路類似在此處就不說(shuō)了
單趟動(dòng)圖如下：
代碼如下：
//快速排序法 挖坑法
void QuickSort1(int* arr, int begin, int end)
{
if (begin >= end)
return;
int left = begin,right = end;
int key = arr[begin];
while (begin < end)
{
//找小
while (arr[end] >= key && begin < end)
{
--end;
}
//小的放到左邊的坑里
arr[begin] = arr[end];
//找大
while (arr[begin] <= key && begin < end)
{
++begin;
}
//大的放到右邊的坑里
arr[end] = arr[begin];
}
arr[begin] = key;
int keyi = begin;
//[left,keyi-1]keyi[keyi+1,right]
QuickSort1(arr, left, keyi - 1);
QuickSort1(arr, keyi + 1, right);
}
6.3 前后指針?lè)?/h3>
思路：
1、選出一個(gè)key，一般是最左邊或是最右邊的。
2、起始時(shí)，prev指針指向序列開(kāi)頭，cur指針指向prev+1。
3、若cur指向的內(nèi)容小于key，則prev先向后移動(dòng)一位，然后交換prev和cur指針指向的內(nèi)容，然后cur指針++；若cur指向的內(nèi)容大于key，則cur指針直接++。如此進(jìn)行下去，直到cur到達(dá)end位置，此時(shí)將key和++prev指針指向的內(nèi)容交換即可。
經(jīng)過(guò)一次單趟排序，最終也能使得key左邊的數(shù)據(jù)全部都小于key，key右邊的數(shù)據(jù)全部都大于key。
然后也還是將key的左序列和右序列再次進(jìn)行這種單趟排序，如此反復(fù)操作下去，直到左右序列只有一個(gè)數(shù)據(jù)，或是左右序列不存在時(shí)，便停止操作
//快速排序法 前后指針版本
void QuickSort2(int* arr, int begin, int end)
{
if (begin >= end)
return;
int cur = begin, prev = begin - 1;
int keyi = end;
while (cur != keyi)
{
if (arr[cur] < arr[keyi] && ++prev != cur)
{
swap(&arr[cur], &arr[prev]);
}
++cur;
}
swap(&arr[++prev],&arr[keyi]);
keyi = prev;
//[begin,keyi -1]keyi[keyi+1,end]
QuickSort2(arr, begin, keyi - 1);
QuickSort2(arr, keyi + 1, end);
}
以上就是快速學(xué)習(xí)六大排序算法的詳細(xì)內(nèi)容，更多關(guān)于六大排序算法的資料請(qǐng)關(guān)注服務(wù)器之家其它相關(guān)文章！
原文鏈接：https://blog.csdn.net/weixin_50886514/article/details/119045154
