以下内容转载自文章
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.堆排序
堆排可看这篇b站讲解
//下标为i的节点的父节点的下标：（i - 1）/ 2
//下标为i的节点的左孩子的下标： i * 2 + 1
//下标为i的节点的右孩子的下标： i * 2 + 1
堆排序：建堆：O(N),维护性质：O(logN) -> O(NlogN)
//数组存放排序结果，同时也是输入，利用堆做中间件，i表示维护性质的起始节点，这是以维护大顶堆的性质为例 -> 数组从小到大排序
void heapify(int arr[], int len, int i)
{
int largest = i;
int left = i * 2 + 1;
int right = i * 2 + 2;
if (left < len && arr[largest] < arr[left])
largest = left;
if (right < len &&arr[largest] < arr[right])
largest = right;
if (largest != i) //即当前i节点不满足大顶堆
swap(&arr[i], &arr[largest]); //开始维护大顶堆的性质
heapify(arr, len, largest);//递归维护孩子节点，看是否满足
}
void heapSort(int arr[], int len)
{
for(int i = (len - 1) / 2; i >= 0; i--)//建堆
{
heapify(arr, len, i); //倒序从数组建立（维护）大顶堆
}
for(int i = len - 1, i > 0; i--)
{
swap[&arr[i], &arr[0]];//排序交换，因为堆顶肯定是最大的，所以交换到最后面 -> 从小到大的顺序
heapify(arr, i, 0); // 交换之后开始维护堆的性质，因为i已经排好序了，所以维护的长度是i，而不是len，并且肯定从堆顶开始维护
}
}6.归并排序
归并排序看这篇b站
//归并排序：分治和递归的思想： O(NlogN)
void merge(int arr[], int tempArr[], int left, int mid, int right)
{
// 标记左半区第一个未排序的元素
int l_pos = left;
// 标记右半区第一个未排序的元素
int r_pos = mid + 1;
// 临时数组元素的下标
int pos = left;
while(l_pos <= mid && r_pos <= right)
{
if (arr[l_pos] < arr[r_pos])
{
tempArr[pos++] = arr[l_pos++];
}
else
{
tempArr[pos++] = arr[r_pos++];
}
}
while (l_pos <= mid)
{
tempArr[pos++] = arr[l_pos++];
}
while (r_pos <= right)
{
tempArr[pos++] = arr[r_pos++];
}
while (left <= right)
{
arr[left] = tempArr[left];
left++;
}
}
void mSort(int arr[], int tempArr[], int left, int right)
{
if (left < right)
{ // 开始分治
int mid = (left + right) / 2;
// 递归划分左半区
mSort(arr, temaArr, left, mid);
// 递归划分右半区
mSort(arr, tempArr, mid + 1, right);
// 排序并合并
merge(arr, tempArr, left, mid, right);
}
}
void mergeSort(int arr[], int len) //排序入口，分治合并需要一个临时数组
{
int tempArr[len];
mSort(arr, tempArr, 0, len - 1);
}7.快速排序
7.2 挖坑法
7.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);
}