1. 插入排序（Insertion Sort）
1.1 定义
将一个数据插入到已经排序好的有序表中，从而产生一个新的、数据量增1的有序表。
1.2 执行过程
外循环确定排序开始下标，内循环进行排序
1.3 源码
void InsertSort(int*a,int n)
{
for(int i=0;i<n-1;i++)
{
int end=i,ret=a[end+1];
while(end>=0)
{
if(a[end]>ret)
{
a[end+1]=a[end];
end--;
}
else
break;
}
a[end+1]=ret;
}
}1.4 复杂度分析
1.4.1 时间复杂度：
最坏情况，数组完全逆序，比较次数为1+2+3+...+n-1,时间复杂度为O(N^2)，最好情况，数组有序，一趟比较即可，时间复杂度为O(N)，平均时间复杂为O(N^2)
1.4.2 空间复杂度：
只需一个变量用于交换，空间复杂度为O(1)。
2. 希尔排序 (Shell's Sort)
2.1 定义
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的数据越来越多，当增量减至 1 时，整个文件恰被分成一组，排序便终止。
2.2 执行过程
首先设置区间，初始区间为整个表的大小，进入循环后划分区间大小后使用插排，直至区间差为1结束循环，排序完成。
2.3 源码
void ShellSort(int*a, int n)
{
int gap = n;
while (gap > 1)
{
//gap/=2;//取一个中间值
gap = gap / 3 + 1;
for (int i = 0; i < n - gap; i++)
{
int end = i;
int ret = a[end + gap];
while (end >= 0)
{
if (a[end] > ret)
{
a[end + gap] = a[end];
end -= gap;
}
else
break;
}
a[end + gap] = ret;
}
}
}
2.4 复杂度分析
2.4.1 时间复杂度：
最坏情况退化为直接插入排序，时间复杂度为O(N^2),最好情况数组有序，一趟比较即可为O(N)。
2.4.2 空间复杂度:
O(1)
3. 堆排序 （Heap Sort）
3.1 定义
3.1.1 堆的概念
堆在逻辑结构上为完全二叉树，其将每个节点所存储的值大于其子节点的为大堆，反之为小堆。
3.1.2 堆的实现
下标为 i 的结点的父结点下标为(i-1)/2，其左右子结点分别为 (2i + 1)、(2i + 2)
很自然就构建出一个堆出来
3.2 执行过程
按照父子节点与数组下标的关系建堆，然后自下向上调整，对父子节点的值进行交换。
3.3 源码
//时间复杂度O(logN)
void DwonAdjust(int *a, int n, int root)//向下调整,左右子树都为同种堆才能使用
{
int parent = root;
int child = parent * 2 + 1;//默认左孩子
while (child<n)
{
//选出左右孩子中大的那一个，建大堆换一下比较符
if (a[child + 1] > a[child] && child < n - 1)
child++;
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
break;
}
}
//整体时间复杂度O(NlogN)
void HeapSort(int*a, int n)
{
//建堆，时间复杂度O(N)
for (int i = (n - 2) / 2; i >= 0; i--)//从最后一个非叶节点调
DwonAdjust(a, n, i);
//排升序建大堆
int end = n - 1;
while (end > 0)
{
Swap(&a[0], &a[end]);
DwonAdjust(a, end, 0);
end--;
}
}交换函数就不用我多说了
3.4 复杂度分析
3.4.1 时间复杂度
堆排序的时间复杂度为O(NlogN),即使原数组为有序的，还是要建堆再一一比较。
3.4.2 空间复杂度
O(1)
4. 选择排序 (Selection Sort)
4.1 定义
第一层循环设置一个最大或最小下标，在第二层循环中，如果有其他下标所对应的值比设置的大或小，则对设置的最大或最小下标进行更新。让后交换第一层循环对应的下标与设置下标所对应的数据。
4.2 执行过程
4.2.1 基础版本
外层循环设置设置一个最大（最小）下标，内层进行比较，选出真正的最大（最小）下标，进行交换。
4.2.2 优化
在交换前加上
if(max!=i)本身为最大（最小）下标无需交换。
4.2.3 再优化
同时从两端寻找最大最小下标，进行交换。
4.3 源码
4.3.1 基础版本
void SelectSort(int*a, int n)
{
for (int i = 0; i < n; i++)
{
int min = i;
for (int j = i + 1; j < n; j++)
{
if (a[min] > a[j])
min = j;
}
Swap(&a[min], &a[i]);
}
}4.3.2 优化
void SelectSort(int*a, int n)
{
for (int i = 0; i < n; i++)
{
int min = i;
for (int j = i + 1; j < n; j++)
{
if (a[min] > a[j])
min = j;
}
if(min!=i)
Swap(&a[min], &a[i]);
}
}4.3.3 再优化
void SelectSort(int*a, int n)
{
int left = 0, right = n - 1;
while (left < right)
{
int min_i = left, max_i = right;
for (int i = left; i <= right; i++)
{
if (a[i] < a[min_i])
min_i = i;
if (a[i] > a[max_i])
max_i = i;
}
if(min_i!=left)
Swap(&a[left], &a[min_i]);
if (max_i != right)
{
if (left == max_i)
max_i = min_i;
Swap(&a[right], &a[max_i]);
}
left++;
right--;
}
}4.4 复杂度分析
4.4.1 时间复杂度
最好情况，最坏全都要比较(n-1+n-2+..+1)*n->n^2/2次，所以时间复杂度为O(N^2)
4.4.2 空间复杂度
空间复杂度，最好情况下（有序）复杂度为：O(0) ，最坏情况下（逆序）复杂度为：O(n );；平均的空间复杂度：O(1)。
5. 冒泡排序 (Bubble Sort)
5.1 定义
重复地走访过要排序的元素列，依次比较两个相邻的元素，根据大小判断进行交换。
5.2 执行过程
5.3 源码
5.3.1 基础版本
void BubbleSort(int*a, int n)
{
for (int i = 0; i < n-1; i++)
{
for (int j = 0; j < n-i-1; j++)
{
if (a[j] > a[j + 1])
Swap(&a[j], &a[j +1]);
}
}
}5.3.2 优化
void BubbleSort(int*a, int n)
{
for (int i = 0; i < n-1; ++i)
{
int flag = 1;
for (int j = 1; j < n- i; ++j)
{
if (a[j - 1] > a[j])
{
Swap(&a[j - 1], &a[j]);
flag = 0;
}
}
if (flag)//未交换直接返回
return;
}
}5. 4 复杂度分析
5.4.1 时间复杂度
平均时间复杂度为O(N)
5.4.2 空间复杂度
O(1)
6. 快速排序 (Quick Sort)
6.1 定义
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以 递归 进行，以此达到整个数据变成有序 序列 ，是分治思想。
6.2 执行过程
6.3 源码
排序的方法主要分为三种，在快排的过程中，每一次我们要取一个元素作为枢纽值，以这个数字来将序列划分为两部分。在此我们采用三数取中法，也就是取左端、中间、右端三个数，然后进行排序，将中间数作为枢纽值，可以很大程度上避免分组"一边倒"的情况。
int GetMid(int*a, int left, int right)
{
int mid = (left + right) >> 1;//相当于除以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[right] > a[left])
return left;
else
return right;
}
}6.3.1 挖坑法
注：引用于八大排序算法（C语言实现）_2021dragon的博客-CSDN博客_八大排序c语言实现
int PartSort1(int*a,int left, int right)
{
int index = GetMid(a, left, right);//保证key取的合理
Swap(&a[left], &a[index]);
int begin = left, end = right;
int pivot = begin;
int key = a[begin];
while (begin < end)
{
//右边找小，放于左边
while (begin < end&&a[end] >= key)
end--;
//小的放到左边的坑里，自己作为新的坑位
a[pivot] = a[end];
pivot = end;
//左边找大
while (begin < end&&a[begin] <= key)
begin++;
//大的放到左边的坑里，自己作为新的坑位
a[pivot] = a[begin];
pivot = begin;
}
pivot = begin;
a[pivot] = key;
return pivot;
}6.3.2 左右指针法
int PartSort2(int*a, int left, int right)
{
int index = GetMid(a, left, right);
Swap(&a[left], &a[index]);
int begin = left, end = right;
int key = begin;
while (begin < end)
{
while (begin<end&&a[end]>=a[key])
end--;
while (begin < end&&a[begin] <= a[key])
begin++;
Swap(&a[begin], &a[end]);
}
Swap(&a[begin], &a[key]);
return begin;
}6.3.3 前后指针法
int PartSort3(int*a, int left, int right)
{
int index = GetMid(a, left, right);
Swap(&a[left], &a[index]);
int key = left, prev = left,cur = left + 1;
while (cur <= right)
{
if (a[cur] < a[key]&&++prev!=cur)
Swap(&a[prev], &a[cur]);
cur++;
}
Swap(&a[prev], &a[key]);
return prev;
}6.3.4 递归实现
void QuickSort(int*a, int left, int right)
{
if (left >= right)
return;
int keyindex = PartSort1(a, left, right);//保证key取的合理
//[left,pivot-1] [pivot] [pivot+1,right]
QuickSort(a, left, keyindex - 1);//分治递归
QuickSort(a, keyindex + 1, right);
}6.3.5 递归优化(小区间优化)
递归次数呈指数增长，在最后几层递归中采用其他排序算法减少递归深度，提高效率。
void QuickSort(int*a, int left, int right)
{
if (left >= right)
return;
//小区间优化后面的大量递归
if (right - left + 1 > 10)//可以设置小区间大小
{
int keyindex = PartSort1(a, left, right);
QuickSort(a, left, keyindex - 1);
QuickSort(a, keyindex + 1, right);
}
else
InsertSort(a, right - left + 1);
}6.3.6 非递归实现
非递归实现需要使用栈，可以参考线性表综合讲述
void QuickSortNotR(int*a, int n)
{
S s;
InitStack(&s);
StackPush(&s, n - 1);
StackPush(&s, 0);
while (!StackEmpty(&s))
{
int left = StackTop(&s);
StackPop(&s);
int right = StackTop(&s);
StackPop(&s);
int keyindex = PartSort1(a, left, right);
if (left < keyindex - 1)
{
StackPush(&s, keyindex-1);
StackPush(&s, left);
}
if (keyindex + 1 < right)
{
StackPush(&s, right);
StackPush(&s, keyindex + 1);
}
}
StackDestory(&s);
}6.4 复杂度分析
6.4.1 时间复杂度
最好O(N),最坏O(N^2),平均为(O(N*logN),这涉及多个函数，比较复杂，但从递归角度看，排序为N，次数为logN.
6.4.2 空间复杂度
O(N)
7. 归并排序 (Merge Sort)
7.1 定义
该算法是采用 分治法 （Divide and Conquer）的一个非常典型的应用。 将已有序的子序列 合并 ，得到完全有序的 序列 ；即先使每个子序列有序，再使子序列段间有序。
7.2 执行过程
先开辟一块与原数据内存等大的内存空间，用于存储排序后的数据，然后取中值分左右进行递归，递归到最深处进入循环取值放入开辟空间中进行排序，最后将值赋给原数据，free掉开辟的空间，排序完成。采用分治思想。
7.3 源码
7.3.1 递归版本
void _MergeSort(int*a, int left, int right, int*temp)
{
if (left >= right)
return;
int mid = (left + right) >> 1;
int begin1 = left, end1 = mid, begin2 = mid + 1, end2 = right;
_MergeSort(a, begin1, end1, temp);
_MergeSort(a, begin2, end2, temp);
int index = left;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
temp[index++] = a[begin1++];
else
temp[index++] = a[begin2++];
}
while (begin1 <= end1)
temp[index++] = a[begin1++];
while (begin2 <= end2)
temp[index++] = a[begin2++];
for (int i = left; i <=right; i++)
a[i] = temp[i];
}
void MergeSort(int *a,int n)
{
int*temp=(int*)malloc(sizeof(int)*n);
_MergeSort(a,0,right,temp);
free(temp);
}7.3.2 非递归版本
void MergeSortNotR(int*a, int n)
{
int*temp = (int*)malloc(sizeof(int)*n);
int gap = 1;//设置间隔
while (gap < n)
{
for (int i = 0; i < n; i += 2 * gap)
{
int begin1 = i, end1 = i + gap - 1,
begin2 = gap + i, end2 = i + 2 * gap - 1;//划定两个区间
//归并时右半区域不存在
if (begin2 >= n)
break;
//归并时右半区域算多了
if (end2 >= n)
end2 = n - 1;
int index = i;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
temp[index++] = a[begin1++];
else
temp[index++] = a[begin2++];
}
while (begin1 <= end1)
temp[index++] = a[begin1++];
while (begin2 <= end2)
temp[index++] = a[begin2++];
for (int j =i; j <=end2; j++)
a[j] = temp[j];
}
gap *= 2;
}
free(temp);
}7.4 复杂度分析
7.4.1 时间复杂度
任何条件下均为O(N*logN)
7.4.2 空间复杂度
使用一块与原数据大小相同的内存空间，空间复杂度为O(N)
注：以下三种排序适用于正整数，其复杂度分析比较复杂
8. 计数排序 (Counting Sort)
8.1 定义
计数排序使用一个额外的辅助数组/计数数组C，其中第i 个元素是待排序数组A 中值等于i 的元素的个数。
8.2 执行过程
8.3 源码
8.3.1 版本一
void CountSort(int*a, int n)
{
int max = a[0];
int min = a[0];
//找出最大最小值
for (int i = 0; i < n; i++)
{
if (a[i] > max)
max = a[i];
if (a[i] < min)
min = a[i];
}
int gap = max - min + 1;
//创建计数数组
int*counta = (int*)calloc(gap,sizeof(int));
for (int i = 0; i < n; i++)
counta[a[i]-min]++;
for (int i = 1; i < gap; i++)
counta[i] += counta[i - 1];
//用一个数组接收排序值
int*newa =(int*)calloc(n, sizeof(int));
for (int i = n - 1; i >= 0; i--)
newa[--counta[a[i] - min]] = a[i];
//赋给原数组
for (int i = 0; i < n; i++)
a[i] = newa[i];
free(counta);
}8.3.2 版本二
void CountSort(int*a, int n)
{
int max = a[0];
int min = a[0];
for (int i = 0; i < n; i++)
{
if (a[i] > max)
max = a[i];
if (a[i] < min)
min = a[i];
}
int gap = max - min + 1;
int*counta = (int*)calloc(gap,sizeof(int));
for (int i = 0; i < n; i++)
counta[a[i]-min]++;
int index = 0;
//相比于方法一，省去累加，用单个计数作为循环赋值
for (int i = 0; i < gap; i++)
{
while (counta[i]--)
a[index++] = i + min;
}
free(counta);
}8.4 复杂度分析
8.4.1 时间复杂度
O(N+M)
8.4.2 空间复杂度
O(N)
9. 桶排序 (Bucket Sort)
9.1 定义
桶排序工作的原理是将数组分到有限数量的桶子里。每个桶子再个别排序。以达有序
9.2 执行过程
我就举个简单的栗子，对下面的代码，桶的大小为一，待排数据为正整数且不重复，将原数据存于对应下标的数组种，使之有序。
9.3 源码
//非正式版本
void BucketSort(int*a, int n)
{
int max = a[0], min = a[0];
for (int i = 0; i < n; i++)
if (a[i] > max)
max = a[i];
int*bucket = (int*)calloc(max+1,sizeof(int));
for (int i = 0; i < n; i++)
bucket[a[i]] = a[i];
for (int i = 0; i < n; i++)
{
for (int j = 0; j <=max; j++)
{
if (bucket[j])
{
a[i] = bucket[j];
bucket[j] = 0;
break;
}
}
}
}9.4 复杂度分析
9.4.1 时间复杂度
O(N+C)
9.4.2 空间复杂度
O(N+M)
10. 基数排序
10.1 定义
基数排序 (Radix Sort)属于分配式排序，又称"桶子法" (Bucket Sort或Bin Sort)，将要排序的元素分配到某些"桶"中，以达到排序的作用。
10.2 执行过程
10.3 源码
#define BASE 10 //进制
void RadixSort(int*a, int n)
{
int*temp = (int*)malloc(sizeof(int)*n);
int max = a[0], gap = 1;
for (int i = 1; i < n; i++)
if (a[i] > max)
max = a[i];
while (max / gap > 0)
{
int*bucket = (int*)calloc(BASE, sizeof(int));
for (int i = 0; i < n; i++)
bucket[(a[i] / gap) % BASE]++;
for (int i = 1; i < BASE; i++)
bucket[i] += bucket[i - 1]; //这部分相当于计数排序
for (int i = n - 1; i >= 0; i--)
temp[--bucket[(a[i] / gap) % BASE]] = a[i]; //取得各位数，并以此为下标赋值
for (int i = 0; i < n; i++)
a[i] = temp[i];
//除数进位
gap *= BASE;
}
free(temp);
}10.4 复杂度分析
10.4.1 时间复杂度
10.4.2 空间复杂度
O(N+K)
注意：本文所引用的图片来自网络素材，如有侵权，请私下磋商。
350
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
