十大排序
- 0.常见排序
- 1. 插入排序（直接插入排序和希尔排序）
- 1.1直接插入排序
- 1.2希尔排序（缩小增量排序）
- 2.选择排序
- 2.1选择排序
- 2. 2堆排序
- 3.交换排序
- 3.1 冒泡排序
- 3.2快速排序
- 3.2.1hoare版本快排
- 3.2.2挖坑法
- 3.2.3前后指针法
- 3.3.4 快排的非递归形式
- 3.3.5快排的优化（随机选key优化）
- 4.归并排序
- 4.1 归并排序非递归形式
- 5.计数排序
0.常见排序
本篇文字会先讲解常见的七大排序，如图所示
最后会有计数排序
1. 插入排序（直接插入排序和希尔排序）
1.1直接插入排序
直接插入排序是一种简单的插入排序法，其基本思想就是把待排序的数值逐一插入到前面以及排好序的元素中，直到全部有序为止。
就如同我们调整扑克牌一样，挑出来一张牌看看前面的数是否比我大，比我大的话我就继续往前对比，直到前一张比我小为止，然后插在后面。
步骤：
1.从第一个元素开始，第一个元素默认为已经排好序。
2.取下一个元素val，与前面的元素逐一比较，如果前面的元素比val大，那么这个元素往后挪，val继续往前比较，如果遇到元素比val小，那么val就插到这个元素后面。如果val比前面的元素都小，那就放在第一个位置。
3.继续取下一个元素，重复2步骤，当取到最后一个元素并排序完成时，整个数组就是有序的了。
动图演示：
代码思路：一开始，第一个元素是有序的，那么我们取有序序列最后元素的下标，将有序序列后一个插入进来，当按规定插入进来后，有序序列元素增加一位，我们再取有序序列最后元素的下标，将有序序列后一个插入进来，一直循环 n - 1次，数组就变得有序了。
void insertSort(int*a,int n)//a是要排序的数组，n是数组大小
{
int end = 0,val = 0;
for(int i = 0;i < n - 1;i++)//注意这里是 n - 1
{
//end记录有序序列最后一个元素的下标
end = i,val = a[end + 1];//拿有序序列后面的最开始的元素。
//单趟排序
while(end >= 0) //到下标0为止
{
if(val < a[end])//如果val比前面的数还小，就继续往前比较。
{
a[end + 1] = a[end];//把比较的数往后挪
end --;//end--，为了下次继续往前比较
}
else //如果前面的数比val还小，就直接break
{
break;
}
}
a[end + 1] = val;//将val插入到比val小的数后面
//继续下一趟for循环
}
}
复杂度分析
时间复杂度：
最坏的情况，逆序 O（n2）
比如 从第二个数开始，往前比较 1 次
到第三个数，往前比较2次
到第四个数，往前比较3次，
到第n个数，往前比较n - 1次
1 + 2 + 3 +…+ n -1 ，是一个等差数列，求和可得
（n2 - 2n + 1）/ 2 ，是一个 n2级别时间复杂度
最好情况，有序，或者接近有序 O（n）
有序情况下，每个数都比前面的数大，所以只需比较一次即可，这时候把数组走完就仅仅达到O（n）级别
空间复杂度：O（1），未开辟额外的数组。
1.2希尔排序（缩小增量排序）
希尔排序是直接插入排序的一种优化版本
其思想是：把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；
随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。
当增量到减小到1时，就是上面所说的直接插入排序，增量大于1时所做的操作，叫做预处理我们的要排序的元素，使其接近有序，我们知道在有序时或者接近有序时，直接插入排序的时间复杂度时O（n）的。
如上图所示，选初始增量gap = 5，第一个数和第一个数后面第gap个数为一组，第二个数和第二个数后面第gap个数为一组。如图所示（9，4）（1，8）（2，6）（5，3）（7，5）各为一组。然后组内排序，整理成（4，9）（1，8）（2，6）（3，5）（5，7）
第一趟排序完成后，第二躺的gap要缩小增量，一般 除以2处理，保证最后的gap是1即可。
代码如下：
void shellSort(int* a, int n)//希尔排序,直接插入排序的优化版
{
int gap = n, end = 0, tmp = 0;
while (gap > 1)
{
gap = gap / 2;
for (int i = 0; i < n - gap; i++) // 一共会有 n - gap 个组
{
end = i;
tmp = a[end + gap];
while (end >= 0)
{
if (tmp < a[end])
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}
复杂度分析
希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排序的时间复杂度都不固定：
《数据结构(C语言版》— 严蔚敏
《数据结构-用面相对象方法与C++描述》— 殷人昆
我们在这里取时间复杂度为O（n1.3）即可
空间复杂度为O（1）
2.选择排序
2.1选择排序
选择排序其基本思想就是：每次从待排序列里面选出一个最小值，然后将这个最小值放在待排序列的起始为止，直到排完即可。
代码如下
void swap(int* a,int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void select(int* a,int n)
{
int begin = 0;
while(begin < n)
{
int mini = begin;
for(int i = begin + 1;i < n;i++)
{
if(a[mini] > a[i])
{
mini = i;
}
}
swap(&a[mini],&a[begin]);
begin++;
}
}
复杂度分析
时间复杂度O（n2）
空间复杂度O（1）
2. 2堆排序
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。
需要注意的是排升序要建大堆，排降序建小堆。
过程如图所示
建好大堆后，每次把堆顶的元素与堆最后的元素交换，然后堆顶向下调整到相应为止。
第二个选择倒数第二个与堆顶交换，然后堆顶向下调整到相应为止。
如此反复直到选到堆顶的数为止，此时堆已经排好序。
在建堆的过程中需要用到建堆算法，具体可以看看这篇文章
堆
代码实现：
void swap(int* a,int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void down(int* a,int n,int parent) //向下调整法代码
{
int child = 2 * parent + 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--) //建堆
{
down(a,n,i);
}
int end = n - 1;
while(end >= 0)
{
swap(&a[end],&a[0]);
down(a,end,0);
--end;
}
}
复杂度分析：
时间复杂度：O（n * log2n）
空间复杂度O（1）
3.交换排序
3.1 冒泡排序
冒泡排序的思路就是两个元素之间两两比较，一趟走完后最大的元素一定在数组的最右边。
然后走第二趟，第二大的元素在数组的倒数第二个位置。
如此循环，有序为止。
void swap(int* a,int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void bubbleSort(int* a,int n)
{
for(int i = 0;i < n;i++)
{
for(int j = 0;j < n - i - 1;j++)
{
if(a[j] > a[j + 1])
{
swap(&a[j],&a[j + 1]);
}
}
}
}
复杂度分析：
时间复杂度：最坏的情况的下也是等差数列的时间复杂度分析，级别是：O（n2） 当然最好的情况是下O（n）的，比如顺序的情况。
空间复杂度O（1）
3.2快速排序
3.2.1hoare版本快排
思路:
1.从数组里面选出一个key，作为基准值。
2.定义一个L作为数组的开头，定义一个R作为数组的末尾。L在数组从左向右走，R在数组从右向左走。如果key是选取最左边的数，R先走，如果key是选取最右边的数，L先走。
3.我们假设选取数组最左边的数作为key，那么R先走，R走的过程中，如果R对应的数小于key,那么此时R停下，轮到L走，如果L走的过程中，碰到大于key的数，那么L停下。停下以后将L和R对应的值交换。然后继续R先走，如此进行下去，直到L和R相遇，将相遇点的内容和key交换即可。
4.从刚才相遇的点分隔开，分为左序列和右序列，都再次执行像3这样的步骤，一直操作下去，当序列只有一个数据或者数据不存在时，便停止操作，此时该序列有序。
单趟动图如下：
代码：
void swap(int* a,int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void quickSort(int* a,int begin,int end)
{
if(begin >= end) return;//当begin>=end，结束递归操作
int L = begin,R = end,key = begin;//定义L,R,key下标
while(L < R)
{
while(a[R] >= a[key] && L < R)//右边先走，右边大于等于key就一直走下去，否则停下来，加上判断L < R，防止越界
{
R--;
}
while(a[L] <= a[key] && L < R)//同理
{
L++;
}
swap(&a[L],&a[R]);//都停下来后交换
}
swap(&a[key],&a[R]);//最后key值和相遇点交换
key = R;//以相遇点作为分界点，递归操作
quickSort(a,begin,key - 1);//递归
quickSort(a,key + 1,end);
}
复杂度分析：
时间复杂度： O（n * log2n）
时间复杂度在原本就是顺序或者逆序的情况下可能达到n2级别，后面会做优化。
空间复杂度O（logn），因为建立了栈帧，开辟的额外的空间
3.2.2挖坑法
挖坑法与hoare法的基本思路类似
挖坑法的基本思路像hoare法一样，在最左边或者最右边选择一个基准值key，然后在该位置挖一个坑。
然后R先走，遇到比key小的就停下来，把这个值放到刚才的坑中，此时坑移到R位置。
然后L先走，遇到比key大的就停下来，把这个值放到刚才的坑中，此时坑移到L的位置。
一直进行下去，直到L和R相遇，最后把key值放到坑中。
然后以这个坑作为分割，分割为左序列和右序列，进行递归操作。
单趟动图演示：
代码：
void quickSort(int* a,int begin,int end)
{
if(begin >= end) return;
int L = begin,R = end,key = a[begin];
int hole = L;
while(L < R)
{
while(a[R] >= key && L < R)
{
R--;
}
a[hole] = a[R];
hole = R;
while(a[L] <= key && L < R)
{
L++;
}
a[hole] = a[L];
hole = L;
}
a[hole] = key;
key = hole;
quickSort(a,begin,key - 1);
quickSort(a,key + 1,end);
}
3.2.3前后指针法
思路：
1、选出一个key，一般是最左边或是最右边的。
2、起始时，pre指针指向序列开头，cur指针指向prev+1。
3、若cur指向的内容小于key，则prev先向后移动一位，然后交换pre和cur指针指向的内容，然后cur指针++；若cur指向的内容大于key，则cur指针直接++。如此进行下去，直到cur到达end位置，此时将key和++prev指针指向的内容交换即可。
经过一次单趟排序，最终也能使得key左边的数据全部都小于key，key右边的数据全部都大于key。
然后也还是将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作
void swap(int* a,int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void quickSort(int* a,int begin,int end)
{
if(begin >= end) return;
int key = begin,pre = begin,cur = begin + 1;
while(cur <= end)
{
while(a[cur] < a[key] && cur != pre)
{
swap(&a[cur],&a[++pre]);
}
cur++;
}
swap(&a[key],&a[pre]);
key = pre;
quickSort(a,begin,key - 1);
quickSort(a,key + 1,end);
}
3.3.4 快排的非递归形式
这里借用栈来改成非递归形式。
主要思想就是利用栈来模拟递归形式，进而改成非递归。
void swap(int* a,int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
//单趟排
int quickSort(int* a,int begin,int end)
{
int key = begin,pre = begin,cur = begin + 1;
while(cur <= end)
{
while(a[cur] < a[key] && cur != pre)
{
swap(&a[cur],&a[++pre]);
}
cur++;
}
swap(&a[key],&a[pre]);
key = pre;
return key;//返回分割点
}
void nonRquick(int* a,int begin,int end)
{
stack<int> s;
s.push(begin);//先入左
s.push(end);//再入右
while(!s.empty())
{
int right = s.top();//得到右下标
s.pop();//弹出
int left = s.top();//得到左下标，现在得到一个区间
s.pop();//弹出
int key = quickSort(a,left,right);//调用函数，执行这个区间的单趟排序，然后得到区间的分割点，接着入栈
if(right > key + 1) //如果有右下标没有大于key + 1就入栈
{
s.push(key + 1); //先入左
s.push(right);//再入右
}
if(left < key) //如果左下标没有大于key就入栈
{
s.push(left);//先入左
s.push(key);//再入右
}
}
}
3.3.5快排的优化（随机选key优化）
当数组里面存在大量的重复数据或者都是重复数的时候，我们的快排的就会退化为 n2级别的排序。
比如{1，1，1，1，1，1，1，1，1，1…}一个数组有很多个1，我们的key始终选在最左边或者最右边的话，快排的效果是非常差的。
所以，基于这个key的选取，我们有三数取中优化和随机选key优化。
常用方法是随机选key
void swap(int* a,int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void quickSort(int* a,int begin,int end)
{
if(begin >= end) return ;
int mid = begin + rand() % (end - begin);//让随机在end - begin内
swap(&a[begin],&a[mid]);//将随机的key与第一个数交换一下
int key = begin,pre = begin,cur = begin + 1;
while(cur <= end)
{
while(a[cur] < a[key] && cur != pre)
{
swap(&a[cur],&a[++pre]);
}
cur++;
}
swap(&a[key],&a[pre]);
key = pre;
quickSort(a,begin,key - 1);
quickSort(a,key + 1,end);
}
4.归并排序
基本思想：
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：
其基本思路就是先把数组一个个分割开，分割到只剩一个的时候，在返回进行归并到另外一个数组里面，再拷贝回原数组。
代码：
void _mergeSort(int* a, int begin, int end, int *tmp)
{
if (begin >= end) return;
int mid = (begin + end) / 2;//每次从之间分割
_mergeSort(a, begin, mid, tmp);//递归分割
_mergeSort(a, mid + 1, end, tmp);
int begin1 = begin, end1 = mid;
int begin2 = mid + 1, end2 = end;
int i = begin;
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++];
}
memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}
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;
}
复杂度分析： 时间复杂度：严格意义上的O（n * log2n）
空间复杂度：O（n）
4.1 归并排序非递归形式
void mergeSort_nonRE(int* a, int n)//归并排序非递归
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc");
exit(-1);
}
int range = 1;
while (range < n)
{
for (int i = 0; i < n; i += 2 * range)
{
int begin1 = i, end1 = i + range - 1;
int begin2 = i + range, end2 = i + 2 * range - 1;
int j = i;
if (end1 >= n)
{
break;
}
else if (begin2 >= n)
{
break;
}
else if (end2 >= n)
{
end2 = n - 1;
}
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] <= a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[j++] = a[begin2++];
}
memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
}
range *= 2;
}
free(tmp);
tmp == NULL;
}
5.计数排序
计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。
主要思想是利用数组统计每个数出现的次数，然后根据出现的次数进行排序。
由于数据的范围可能是负数，也可能是过大的数据，我们不可能开出负数下标的数组，也应避免牺牲太大的空间存放对应值的下标。
所以我们采用 映射的关系，即将某些值利用某种方法对应到相应的下标。
我们这里先算出数据的最大范围，开出相应大小的数组。
比如数据是 1001 1002 1003 1004 1005
最大值是1005 最小值是1001，
最大值减最小值等于5，所以数组的大小是5。
映射关系是： a[元素 - 最小值],比如a[1001-1001]，就是a[0]，所以
a[0]存放着1001这个数。
这种映射关系巧妙地解决了负数和数据过大等问题。
代码：
void countSort(int* a, int n)//计数排序
{
int max1 = a[0], min1 = a[0];
for (int i = 0; i < n; i++)
{
if (a[i] > max1)
{
max1 = a[i];
}
if (a[i] < min1)
{
min1 = a[i];
}
}
int range = max1 - min1 + 1;
int* count = (int*)calloc(range, sizeof(int));
if (count == NULL)
{
perror("malloc");
exit(-1);
}
for (int i = 0; i < n; i++)
{
count[a[i] - min1] ++;//利用哈希的方法计数
}
int k = 0;
for (int i = 0; i < range; i++)
{
while (count[i]--)
{
a[k++] = i + min1;
}
}
free(count);
count = NULL;
}
复杂度分析：
时间复杂度O（N + range）
空间复杂度O（N）
