目录
插入排序
插入排序思想：把待排序的值的大小逐个插入到一个已经排好序的有序序列中，直到所有的值插入完为止，得到一个新的有序序列 。
代码：
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;
}
}插入排序特点：
1.时间复杂度为O(n^2)
2.空间复杂度为O(1)
3.稳定，不会改变相同值的先后次序
4.当序列趋近于有序时，插入排序将达到巅峰O(n)
希尔排序
希尔排序是在插入排序基础上进行优化的，当对一个非常长的序列进行排序时，希尔排序很优秀。
希尔排序思想：先将序列分成gap组，对每组进行插入排序，多组并排，gap由大变小，使整个序列趋向于有序，最后gap变成1再进行直接插入排序。
代码：
void ShellSort(int* a, int n)
{
//希尔排序：先多组并排使其趋向有序，然后再进行插入排序，
// 时间复杂度：n*logn，大概是n^1.3
//第一种写法，分开写
int gap = n;
//while (gap /= 2)
//{
// //对所有组排序
// for (int j = 0; j < gap; j++)
// {
// //对一组排序
// for (int i = j; i < n - gap; i += gap)
// {
// 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;
// }
// }
//}
//第二种写法：一锅炖
while (gap/=2)
{
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;
}
}
}希尔排序特点：
1.时间复杂度大概为O(n*logn)
2.空间复杂度为O(1)
3.是在直接插入排序基础上优化形成的
4.不稳定
选择排序
选择排序思想：遍历一遍序列，找出最值，放到边界上。
代码：
void SelectSort(int* a, int n)
{
int begin = 0, end = n - 1;
while (begin<end)
{ //采用下标保存最大和最小元素的位置
int mini = begin, maxi = begin;
for (int i = begin+1; i <= end; i++)
{
if (a[i] < a[mini])
{
mini = i;
}
if (a[i] > a[maxi])
{
maxi = i;
}
}
Swap(&a[mini], &a[begin]);
//这里注意：如果maxi位置与begin相同，要进行修正！
if (maxi == begin)
{
maxi = mini;
}
Swap(&a[maxi], &a[end]);
begin++;
end--;
}
}选择排序特点：
1.时间复杂度为O(n^2)
2.空间复杂度为O(1)
3.不稳定
4.选择排序可以说是最慢的排序，一般不推荐使用。
堆排序
堆排序思想：堆排序思想与选择排序相同，但效率高很多。
先将序列构建成堆，这样最值就在堆顶，趋近与有序，每选出一个最值后调整一次。
需要注意的是排升序要建大堆，排降序建小堆。
代码：
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[end], &a[0]);
adjustdown(a, end, 0);
}
}堆排序特点：
1.时间复杂度为O(n*logn)
2.空间复杂度为O(1)
3.是在选择排序基础上优化的，效率高很多
4.不稳定
冒泡排序
冒泡排序思想：序列中从起始位置开始，前一个位置与后一个位置比较，若前大于后，则交换，这样就能将大值往尾部移动。
代码：
void BubbleSort(int* a, int n)
{
for (int i = 0; i < n - 1; i++)
{
for (int j = 0; j < n - 1 - i; j++)
{
if (a[j] > a[j + 1])
{
Swap(&a[j + 1], &a[j]);
}
}
}
}冒泡排序特点：
1.时间复杂度为O(n^2)
2.空间复杂度为O(1)
3.稳定
快速排序
快速排序思想：选取序列中一个元素作为基准值，将序列分成两段，左边全小于基准值，右边全大于基准值，这样基准值就放在了正确的位置上，然后对左右序列重复这段过程。
快速排序是有缺陷的，如果选的基准值为最值，那么第一次操作N-1次，第二次N-2，以此类推，时间复杂度趋于O（n^2）,所以我们可以用三数取中法进行优化。
但如果极端情况下序列中值全部相同，这种情况下快速排序缺陷无法消除。
代码：
三数取中
//三数取中，化有序为无序，解决数组有序时速度慢的问题
int Getmid(int* a, int left,int right)
{
int mid = (left + right) / 2;
if (a[mid] > a[left])
{
if (a[left] > a[right])
{
return left;
}
else if (a[right] > a[mid])
{
return mid;
}
else
{
return right;
}
}
else//a[left]>a[mid]
{
if (a[right] > a[left])
{
return left;
}
else if (a[mid] > a[right])
{
return mid;
}
else
{
return right;
}
}
}hoare版本
取左边界为基准值，右边先走，找比基准值小的数，左边再走，找比基准值大的数，然后交换，当左右相遇，此时的值一定比基准值小，然后将此位置与左边界交换，就完成了。
若取右边为基准值：左边先走，其他与上面一致。
//hoare版本
int Partion1(int* a, int left,int right)
{
int mid = Getmid(a, left, right);
Swap(&a[left], &a[mid]);
//取左边为key，右边先走
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;
}挖坑法
取左边界为基准值，并把值保存，然后把此位置视为一个坑，然后右边找小值，与坑交换，
再把当前位置看成坑，然后左边找大值，再与坑交换，把当前位置看为坑，当左右相遇时，把基准值填补进坑。
//挖坑法
int Partion2(int* a, int left, int right)
{
int mid = Getmid(a, left, right);
Swap(&a[left], &a[mid]);
//选左边做值，并保存
int pivot = left;
int x = a[pivot];
while (left<right)
{
while (left<right&&a[right]>=x)
{
right--;
}
a[pivot] = a[right];
pivot = right;
while (left<right&&a[left]<=x)
{
left++;
}
a[pivot] = a[left];
pivot = left;
}
a[pivot] = x;
return pivot;
}
双指针法
取左值为基准值，prev指向左边界，cur指向左边界+1，然后cur向后找比基准值小的数，找到后++prev位置与cur位置值交换，若没找到，cur就++，直到cur>right也就是右边界。
然后再把prev位置值与基准值交换。
//双指针法
int Partion3(int* a, int left, int right)
{
//选左边做值
int keyi = left;
int prev = left;
int cur = left + 1;
while (cur<=right)
{//找小
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 mid = Partion3(a, left, right);
QuickSort(a, left, mid - 1);
QuickSort(a, mid + 1, right);
}非递归版
利用栈模拟递归过程。
将序列不断分割，结构类似于二叉树前序遍历。
//非递归，利用栈模拟
void QuickSortNoR(int* a, int left, int right)
{
Stack st;
StackInit(&st);
StackPush(&st, left);
StackPush(&st, right);
while (!StackEmpty(&st))
{
int end = StackTop(&st);
StackPop(&st);
int begin = StackTop(&st);
StackPop(&st);
int mid = Partion1(a, begin, end);
if (end > mid + 1)
{
StackPush(&st, mid + 1);
StackPush(&st, end);
}
if (begin < mid - 1)
{
StackPush(&st, begin);
StackPush(&st, mid - 1);
}
}
}快速排序特点：
1.时间复杂度为O(n*logn)
2.空间复杂度为O(1)
3.不稳定
4.极端情况下不适用
归并排序
归并排序思想：先使每个子序列有序，再使子序列段间有序，最后进行归并。
先11归，再22归，再44归..............依次类推。
代码：
递归版
void _MergeSort(int* a, int left, int right,int *tmp)
{
if (left >= right)
{
return;
}
//思路：先将左右区间排成有序，然后进行归并
int mid = (left + right) / 2;
_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 i = left; i <= right; i++)
{
a[i] = tmp[i];
}
}
void MergeSort(int* a,int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc");
exit(-1);
}
_MergeSort(a, 0, n-1, tmp);
free(tmp);
tmp = NULL;
}非递归版
void MergeSortNoR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc");
exit(-1);
}
//由小变大，11归，22归，---
int gap = 1;
while (gap < n)
{
for (int i = 0; i < n; i += 2 * gap)
{
//[i,i+gap-1],[i+gap,i+2*gap-1]两个区间归并
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
int index = i;
//注意边界控制
//1.end1越界，[begin2,end2]不存在
//2.begin2越界,[begin2,end2]不存在
//3.end2越界
//如果排完再拷贝
if (end1 >= n)
{
end1 = n - 1;
}
if (begin2 >= n)
{
begin2 = n;
end2 = n - 1;
//这样使[begin2,end2]不进入循环
}
if (end2 >= n)
{
end2 = n - 1;
}
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] <= a[begin2])
{
tmp[index++] = a[begin1++];
}
else
{
tmp[index++] = a[begin2++];
}
}
while (begin1<=end1)
{
tmp[index++] = a[begin1++];
}
while (begin2<=end2)
{
tmp[index++] = a[begin2++];
}
}
//排完一整组再拷贝
for (int i = 0; i < n; i++)
{
a[i] = tmp[i];
}
gap *= 2;
}
free(tmp);
}
void MergeSortNoR2(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc");
exit(-1);
}
//由小变大，11归，22归，---
int gap = 1;
while (gap < n)
{
for (int i = 0; i < n; i += 2 * gap)
{
//[i,i+gap-1],[i+gap,i+2*gap-1]两个区间归并
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
int index = i;
//注意边界控制
//1.end1越界，[begin2,end2]不存在
//2.begin2越界,[begin2,end2]不存在
//3.end2越界
//如果排一次拷贝一次
if (end1 >= n || begin2 >= n)
{
break;
}
if (end2 >= n)
{
end2 = n - 1;
}
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] <= a[begin2])
{
tmp[index++] = a[begin1++];
}
else
{
tmp[index++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[index++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[index++] = a[begin2++];
}
//排一次就拷贝
for (int j = i; j <= end2; j++)
{
a[j] = tmp[j];
}
}
gap *= 2;
}
free(tmp);
}归并排序特点：
1.时间复杂度为O(n*logn)
2.空间复杂度为O(n)
3.稳定
计数排序
计数排序思想：遍历一遍序列，统计相同元素出现的次数，根据次数排序。
代码：
void CountSort(int* a, int n)
{
int min = a[0], max = a[0];
//找出最大最小值，开创空间
for (int i = 0; i < n; i++)
{
if (a[i] < min)
{
min = a[i];
}
if (a[i] > max)
{
max = a[i];
}
}
//相对映射
int range = max - min + 1;
int* count = (int*)malloc(sizeof(int) * range);
memset(count, 0, sizeof(int) * range);
for (int i = 0; i < n; i++)
{
count[a[i] - min]++;
}
int j = 0;
for (int i = 0; i < range; i++)
{
while (count[i]--)
{
a[j++] = i + min;
}
}
free(count);
}计数排序特点：
1.时间复杂夫maxO(n,range)
2.空间复杂度maxO(n,range)
3.不稳定
4.在数据范围集中时，效率很高，但是适用范围及场景有限
本片文章到此结束。
1385
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
