文章目錄:
- 1. 插入排序
- 2.希爾排序
- 3.選擇排序
- 4.冒泡排序
- 5.堆排序
- 6.快速排序
-
- 5.1 hoare版本(左右指針法)
- 5.2 挖坑法
-
- 5.2.1 遞歸
- 5.2.2 非遞歸
- 5.3 前後指針法
1. 插入排序
步驟:
1.從第一個元素開始,該元素可以認為已經被排序
2.取下一個元素tem,從已排序的元素序列從後往前掃描
3.如果該元素大于tem,則将該元素移到下一位
4.重複步驟3,直到找到已排序元素中小于等于tem的元素
5.tem插入到該元素的後面,如果已排序所有元素都大于tem,則将tem插入到下标為0的位置
6.重複步驟2~5
動圖示範如下:
思路:
在待排序的元素中,假設前n-1個元素已有序,現将第n個元素插入到前面已經排好的序列中,使得前n個元素有序。按照此法對所有元素進行插入,直到整個序列有序。
但我們并不能确定待排元素中究竟哪一部分是有序的,是以我們一開始隻能認為第一個元素是有序的,依次将其後面的元素插入到這個有序序列中來,直到整個序列有序為止。
代碼如下:
void InsertSort(int* arr, int n)
{
for (int i = 0; i < n - 1; ++i)
{
//記錄有序序列最後一個元素的下标
int end = i;
//待插入的元素
int tem = arr[end + 1];
//單趟排
while (end >= 0)
{
//比插入的數大就向後移
if (tem < arr[end])
{
arr[end + 1] = arr[end];
end--;
}
//比插入的數小,跳出循環
else
{
break;
}
}
//tem放到比插入的數小的數的後面
arr[end + 1] = tem;
//代碼執行到此位置有兩種情況:
//1.待插入元素找到應插入位置(break跳出循環到此)
//2.待插入元素比目前有序序列中的所有元素都小(while循環結束後到此)
}
}
時間複雜度:最壞情況下為O(N*N),此時待排序列為逆序,或者說接近逆序
最好情況下為O(N),此時待排序列為升序,或者說接近升序。
空間複雜度:O(1)
2.希爾排序
步驟:
1.先標明一個小于N的整數gap作為第一增量,然後将所有距離為gap的元素分在同一組,并對每一組的元素進行直接插入排序。然後再取一個比第一增量小的整數作為第二增量,重複上述操作…
2.當增量的大小減到1時,就相當于整個序列被分到一組,進行一次直接插入排序,排序完成。
動圖如下:
思路:
希爾排序,先将待排序列進行預排序,使待排序列接近有序,然後再對該序列進行一次插入排序,此時插入排序的時間複雜度為O(N),
代碼如下:
//希爾排序
void ShellSort(int* arr, int n)
{
int gap = n;
while (gap>1)
{
//每次對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;
}
}
}
時間複雜度平均:O(N^1.3)
空間複雜度:O(1)
3.選擇排序
思路:
每次從待排序列中選出一個最小值,然後放在序列的起始位置,直到全部待排資料排完即可。
實際上,我們可以一趟選出兩個值,一個最大值一個最小值,然後将其放在序列開頭和末尾,這樣可以使選擇排序的效率快一倍。
動圖如下:
代碼如下:
//選擇排序
void swap(int* a, int* b)
{
int tem = *a;
*a = *b;
*b = tem;
}
void SelectSort(int* arr, int n)
{
//儲存參與單趟排序的第一個數和最後一個數的下标
int begin = 0, end = n - 1;
while (begin < end)
{
//儲存最大值的下标
int maxi = begin;
//儲存最小值的下标
int mini = begin;
//找出最大值和最小值的下标
for (int i = begin; i <= end; ++i)
{
if (arr[i] < arr[mini])
{
mini = i;
}
if (arr[i] > arr[maxi])
{
maxi = i;
}
}
//最小值放在序列開頭
swap(&arr[mini], &arr[begin]);
//防止最大的數在begin位置被換走
if (begin == maxi)
{
maxi = mini;
}
//最大值放在序列結尾
swap(&arr[maxi], &arr[end]);
++begin;
--end;
}
}
時間複雜度:最壞情況:O(N^2)
最好情況:O(N^2)
空間複雜度:O(1)
4.冒泡排序
思路:
左邊大于右邊交換一趟排下來最大的在右邊
動圖如下:
代碼如下:
//冒泡排序
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;
}
}
時間複雜度:最壞情況:O(N^2)
最好情況:O(N)
空間複雜度:O(1)
5.堆排序
堆排可看之間這篇博文----->[堆排]
6.快速排序
5.1 hoare版本(左右指針法)
思路:
1、選出一個key,一般是最左邊或是最右邊的。
2、定義一個begin和一個end,begin從左向右走,end從右向左走。(需要注意的是:若選擇最左邊的資料作為key,則需要end先走;若選擇最右邊的資料作為key,則需要bengin先走)。
3、在走的過程中,若end遇到小于key的數,則停下,begin開始走,直到begin遇到一個大于key的數時,将begin和right的内容交換,end再次開始走,如此進行下去,直到begin和end最終相遇,此時将相遇點的内容與key交換即可。(選取最左邊的值作為key)
4.此時key的左邊都是小于key的數,key的右邊都是大于key的數
5.将key的左序列和右序列再次進行這種單趟排序,如此反複操作下去,直到左右序列隻有一個資料,或是左右序列不存在時,便停止操作,此時此部分已有序
單趟動圖如下:
代碼如下:
//快速排序 hoare版本(左右指針法)
void QuickSort(int* arr, int begin, int end)
{
//隻有一個數或區間不存在
if (begin >= end)
return;
int left = begin;
int right = end;
//選左邊為key
int keyi = begin;
while (begin < end)
{
//右邊選小 等号防止和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);
}
時間複雜度: 快速排序的過程類似于二叉樹其高度為logN,每層約有N個數,如下圖所示:
5.2 挖坑法
5.2.1 遞歸
思路:
挖坑法思路與hoare版本(左右指針法)思路類似
1.選出一個資料(一般是最左邊或是最右邊的)存放在key變量中,在該資料位置形成一個坑
2、還是定義一個L和一個R,L從左向右走,R從右向左走。(若在最左邊挖坑,則需要R先走;若在最右邊挖坑,則需要L先走)
後面的思路與hoare版本(左右指針法)思路類似在此處就不說了
單趟動圖如下:
代碼如下:
//快速排序法 挖坑法
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);
}
5.2.2 非遞歸
//單趟排
int PartSort(int* arr, int begin, int end)
{
int key = arr[begin];
while (begin < end)
{
while (key <= arr[end] && begin < end)
{
--end;
}
arr[begin] = arr[end];
while (key >= arr[begin] && begin < end)
{
++begin;
}
arr[end] = arr[begin];
}
arr[begin] = key;
int meeti = begin;
return meeti;
}
void QuickSortNoR(int* arr, int begin, int end)
{
stack<int> st;
//先入右邊
st.push(end);
//再入左邊
st.push(begin);
while (!st.empty())
{
//左區間
int left = st.top();
st.pop();
//右區間
int right = st.top();
st.pop();
//中間數
int mid = PartSort(arr, left, right);
//當左區間>=mid-1則證明左區間已經排好序了
if (left < mid - 1)
{
st.push(mid - 1);
st.push(left);
}
//當mid+1>=右區間則證明右區間已經排好序
if (right > mid + 1)
{
st.push(right);
st.push(mid + 1);
}
}
}
5.3 前後指針法
思路:
1、選出一個key,一般是最左邊或是最右邊的。
2、起始時,prev指針指向序列開頭,cur指針指向prev+1。
3、若cur指向的内容小于key,則prev先向後移動一位,然後交換prev和cur指針指向的内容,然後cur指針++;若cur指向的内容大于key,則cur指針直接++。如此進行下去,直到cur到達end位置,此時将key和++prev指針指向的内容交換即可。
經過一次單趟排序,最終也能使得key左邊的資料全部都小于key,key右邊的資料全部都大于key。
然後也還是将key的左序列和右序列再次進行這種單趟排序,如此反複操作下去,直到左右序列隻有一個資料,或是左右序列不存在時,便停止操作
//快速排序法 前後指針版本
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);
}