万字详解八大排序 必读（代码+动图演示）

目录

1.排序的概念及其运用

1.1排序的概念

1.2排序的运用

1.3常见的排序算法

2.常见的排序算法

2.1插入排序

2.1.1直接插入排序

2.1.2希尔排序

2.2选择排序

2.2.1直接选择排序

2.2.2堆排序

2.3交换排序

2.3.1冒泡排序

2.3.2快速排序

        2.3.2.1Hoare

        2.3.2.2挖坑法

        2.3.2.3双指针法

2.4归并排序

2.4.1递归实现归并排序

2.4.2迭代实现归并排序

 2.5计数排序

3.八大排序对比

3.1性能测试评估

3.2排序算法复杂度及稳定性分析

---

 

1.排序的概念及其运用

1.1排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

1.2排序的运用

U.S.News2022年的大学排行榜

1.3常见的排序算法

2.常见的排序算法

交换函数，后面会用到

void Swap(int* p, int* q)
{
	int tmp = *p;
	*p = *q;
	*q = tmp;
}
 

2.1插入排序

基本思想

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。比如我们过年和亲朋好友一起打扑克牌的时候，把牌理好的过程中就使用了插入排序的方法。

2.1.1直接插入排序

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。

动图展示

 代码实现

//直接插入排序
void InsertSort(int* a, int n) {
	assert(a);
	for (int i = 0; i < n - 1 ; i++){
		//end表示排好序的尾标
		int end = i;
		//保存要排序的数，不然会被覆盖
		int tmp = a[end + 1];
		//只要坐标end的数大于end+1的数，那么end的数就要向后移动一位
		while (end >= 0) {
			if (tmp < a[end]) {
				a[end + 1] = a[end];
				--end;
			}
			else
				break;
		}
//不管是end<0退出，还是a[end+1]>a[end]退出，a[end+1]的值都要放到end的后一个位置上
		a[end + 1] = tmp;
	}
}

 复杂度分析

最好的情况是排序的表本身有序，数组中每个元素都与前一个比较一次，而且不用移动，时间复杂度是O(N)，最坏的情况是待排序表是逆序的，比较和移动都到达最大值，时间复杂度是O(N^2)。只需要一个辅助空间，所以空间复杂度是O(1)。

2.1.2希尔排序

基本思想

希尔排序（ShellSort）又称为“缩小增量排序”。是1959年由D.L.Shell提出来的。该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

动图展示

希尔排序的特性

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此希尔排序的时间复杂度都不固定：

代码实现

//希尔排序
void ShellSort(int* a, int n) {
	int gap = n;
	//gap始终大于等于，大于1为预排序
	while (gap > 1) {
		//每一趟预排序的gap都不一样，gap会越来越小
		gap /= 3 + 1;
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0 && a[end] > tmp) {
	//只要坐标end的数大于end + gap的数，那么end的数就要向后移动gap位
				a[end + gap] = a[end];
				end -= gap;
			}
			a[end + gap] = tmp;
		}
	}
}
	

 复杂度分析

究竟应该选取什么样的增量才是最好的，目前还是一个数学难题，迄今为止还没人找到一种最好的增量序列，导致时间复杂度很难去计算，因此在很多书中给出的希尔排序的时间复杂度都不固定。
下面从两本经典的数据结构书籍中截取了两段对复杂度的描述。

 《数据结构(C语言版)》— 严蔚敏

 《数据结构-用面相对象方法与C++描述》— 殷人昆

 

2.2选择排序

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

2.2.1直接选择排序

基本思想

在元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素，若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换，在剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

 动图展示

代码实现 

void SelectSort(int* a, int n) {
	for (int i = 1; i < n; i++) {
      //将第一个小标定义为最小值的下标
		int min = i - 1;              
		for (int j = i; j < n; j++) {
     //如果后面有小于最小值的关键字，就交换下标
			if (a[j] < a[min]) { 
				min = j;
			}
		}
     //min != i-1,说明找到最小值，交换
		if (min != i - 1) {
			Swap(&a[min], &a[i - 1]);
		}
	}
}

 复杂度分析

无论最好还是最坏的情况，其比较的次数都是一样的多，第i趟排序需要进行n-i次关键字的比较，所以总共需要比较1/2*n(n-1)次，最好的时候交换0次，最差的时候交换n-1次，最终时间复杂度为O(N^2),空间复杂度是O(1),可以看出选择排序效率很差，实际中很少用。

2.2.2堆排序

基本思想

利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

动图展示

代码实现

void AdjustDwon(int* a, int n, int root) {
	int parent = root;
	int child = parent * 2 + 1;
	while (child < n) {
		if (child + 1 < n && a[child] < a[child + 1]) {
			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 - 2) / 2; i >= 0; i--) {
		AdjustDwon(a, n, i);
	}
//把堆顶的数据和堆尾的数据进行交换，在进行向下调整成大堆，不过堆尾的数据不进行调整，再把堆顶数 
//据和堆尾数据进行交换，然后以此类推。
	int end = n ;
	while (--end > 0) {
		Swap(&a[0], &a[end]);
		AdjustDwon(a, end, 0);
	}
}

 复杂度分析

在正式排序时，第i次取堆顶记录重建堆需要用O(nlogi)的时间（完全二叉树的某个节点到根节点的距离为[log2^k]+1，并且需要取n-1次堆顶记录，因此，重建堆的时间复杂度为O(nlogn),所以总体来说，堆排序时间复杂度为O(nlogn)，空间复杂度为O(1)。

2.3交换排序

所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排
序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

2.3.1冒泡排序

基本思想

两两比较相邻记录的关键字，如果反序就交换，直到没有反序的记录为止

动图展示

代码实现

void BubbleSort(int* a, int n) {
	for (int i = 1; i < n; i++) {
		int flag = 0;
		for (int j = n - 1; j >= i; j--) {  //j是从后往前循环
			if (a[j] < a[j - 1]) {
				//若后面的数比前一个小，就交换，每一趟都会把小的数往前挪
				Swap(&a[j], &a[j - 1]);
				flag = 1;
			}
		}
		if (flag == 0)  //若flag==0，说明这一轮没有发生交换，数组已经有序了，直接退出
			break;
	}
}

复杂度分析

最好的情况，也就是待排序表本身就是有序的，那么需要比较n-1次，没有数据交换，时间复杂度为O(n），最坏的情况就是待排序表是逆序的，需要比较1+2+3+...+(n-1)=1/2*n(n-1)次，因此时间复杂度为O(N^2)，空间复杂度为O(1)。

2.3.2快速排序

2.3.2.1Hoare

基本思想

分别使用左右两个指针指向待排序数组的头和尾，再选出一个key值，一般把第一个元素作为key值，右指针向左移动，找到比key值小的元素停下来，然后左指针向右移动，找到比key值大的元素停下来，然后交换左右指针指向的元素，继续上述步骤，直到两指针相遇，将key下标的值与相遇处的值交换。

注意：

      · 如果我们取头值作为我们的key值，那么我们一定要让右指针先移动

      · 如果我们取尾值作为我们的key值，那么我们一定要让左指针先移动

这样可以确保最后相遇时的a[left]<a[key]， 

动图展示

单趟排序

int PartSort1(int* a, int left, int right) {
	int key = left;
	//找小
	while (left < right) {
		while (left < right && a[right] >= a[key]) {
			--right;
		}
		//找大
		while (left < right && a[left] <= a[key]) {
			++left;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[key]);
	return left;
}

全趟排序

void QuickSort(int* a, int left, int right) {
   //当区间分割到只剩一个或者没有的时候就不用排序了
	if (left < right) {
		int keyi = PartSort1(a, left, right);
		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}
}

 复杂度分析

如果每次选取的key值正好是待排序的中间值，那么排序n个关键字，其递归树可以近似看出是一颗满二叉树，递归深度为log2^(n+1)，所需时间复杂度为O(n*logn)，最坏的情况是待排序序列为正序或者逆序，每次划分只得到一个比上一次划分少一个记录的子序列，其递归树是一颗斜树，此时需要递归n-1次，需要比较n-1+n-2+...+2+1=1/2*(n*n-1))，其时间复杂度为O(n^2）。空间复杂度都为logn。

我们可以对这个最坏的情况进行优化，方法有：1.可以随机选取key值，2.可以采用三数取中法，3.小区间优化

三数取中法

基本思想

取三个关键字先进行排序，将中间数作为枢轴，一般取最左端、最右端和中间三个数

代码实现

int Threedigit(int* a, int left, int right) {
	int mid = (left + right) >> 2;
	if (a[left] > a[mid]) {
		if (a[mid] > a[right]) {
			return mid;
		}
		else if (a[left] > a[right]) {
			return right;
		}
		else {
			return left;
		}
	}
	else {
		if (a[mid] < a[right]) {
			return mid;
		}
		else if (a[left] > a[right]) {
			return left;
		}
		else {
			return right;
		}
	}
}

2.3.2.2挖坑法

基本思想

把第一个值作为key值，把它当作坑位，把第一个数拿出来放到tmp变量保存好，右指针往左移动，找到比key小的值放到坑位中，行成新的坑位，左指针往右找到比key大的值放到坑位中，有形成新的坑位，直到两指针相遇（两指针一定会在坑位中相遇），再把tmp中的值放到相遇的地方。

动图展示

代码实现

单趟排序

int PartSort2(int* a, int left, int right) {
	int tmp = Threedigit(a, left, right);
	Swap(&a[left], &a[tmp]);
	int key = a[left];
	while (left < right) {
		//找小
		while (left < right && a[right] >= key) {
			--right;
		}
		//把right位置的值赋给left位置，right位置就是坑位了
		a[left] = a[right];
		while (left < right && a[left] <= key) {
			++left;
		}
		//left指向比key大的值的位置，把left位置的值赋给right,left就是坑位了
		a[right] = a[left];
	}
	a[left] = key;
	return left;
}

全趟排序

void QuickSort(int* a, int left, int right) {
	if (left < right) {
		int keyi = PartSort1(a, left, right);
		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}
}

 2.3.2.3双指针法

基本思想

需要两个指针，一个在前一个在后，分别用cur表示前指针，用prev表示后指针，初始时，规定cur在prev的后一个位置，还是选择第一个数为基准值，如果cur的值大于基准值，这时只让cur++，如果cur指向的位置小于基准值这时我们让prev++，判断prev++后是否与cur的位置相等，若不相等，则交换cur和prev的值，直到最后，我们再交换prev和key，这样基准值的位置也就确定了。

动图展示

代码实现

单趟排序

int PartSort3(int* a, int left, int right) {
	int tmp = Threedigit(a, left, right);
	Swap(&a[left], &a[tmp]);
	int prev = left, cur = left + 1, key = left;
	while (cur <= right) {
		if (a[cur] < a[key] && ++prev != cur) {
			Swap(&a[cur], &a[prev]);
		}
		++cur;
	}
	Swap(&a[left], &a[prev]);
	return prev;
}

全趟排序

void QuickSort(int* a, int left, int right) {
	if (left < right) {
		int keyi = PartSort1(a, left, right);
		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}
}

 2.3.2.4快速排序非递归

前面三种方法用的都是递归方法，但是递归是有缺陷的，可能很多人觉得递归多次调用栈空间会影响性能，但是现在的编译器优化的很好，性能已经不是大问题了，最大的问题是如果递归深度太深，程序本身没问题，但是栈空间不够，会导致栈溢出，所以可以写成非递归形式，非递归有两种形式：1.直接改循环（斐波那契数求解），2.用栈存储数据模拟递归过程（树遍历非递归、快排非递归等等）。

基本思想

非递归的在这里借助栈，依次把我们需要单趟排的区间入栈，依次取栈里面的区间出来单趟排，再把需要处理的子区间入栈，以此循环，直到栈为空的时候即处理完毕。

代码实现

void QuickSortNonR(int* a, int left , int right) {
	Stack ph;
	StackInit(&ph);
	StackPush(&ph, left);
	StackPush(&ph, right);
	while (!StackEmpty(&ph)) {
		right = StackTop(&ph);
		StackPop(&ph);
		left = StackTop(&ph);
		StackPop(&ph);
		int keyi = PartSort1(a, left, right);
		if (left < keyi - 1) {
			StackPush(&ph, left);
			StackPush(&ph, keyi - 1);
		}
		if (keyi + 1 < right) {
			StackPush(&ph, keyi + 1);
			StackPush(&ph, right);
		}
	}
	StackDestory(&ph);
}

复杂度分析

时间复杂度：O(n*logn)

空间复杂度：O(logn)

2.4归并排序

基本思想

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

2.4.1递归实现归并排序

核心步骤

 代码实现

void Merge(int* a, int begin1, int end1, int begin2, int end2, int* tmp) {
	int i = begin1;
	int j = begin1;
	while (begin1 <= end1 && begin2 <= end2) {
//两段区间内的数据挨个比较
		if (a[begin1] < a[begin2]) {
			tmp[i++] = a[begin1++];
		}
		else {
			tmp[i++] = a[begin2++];
		}
	}
//走到这里说明至少有一个区间没数据了，不知道是哪段区间没数据，需要挨个判断
//若第一段区间还有数据则全部拷贝到tmp中，说明第二段没有了
	while (begin1 <= end1) {
		tmp[i++] = a[begin1++];
	}
//若第二段区间还有数据则全部拷贝到tmp中，说明第一段没有了
	while (begin2 <= end2) {
		tmp[i++] = a[begin2++];
	}
    //归并完，再把tmp数组数据拷贝到原数组
	for (; j <= end2; j++)
	{
		a[j] = tmp[j];
	}
}

void _MergeSort(int* a, int left, int right, int* tmp) {
//当分解到只剩一个的时候返回，进行归并
	if (left >= right) {
		return;
	}
	int mid = (left + right) >> 1;
	_MergeSort(a, left, mid, tmp);
	_MergeSort(a, mid + 1, right, tmp);
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
//对两段区间内的数据进行归并
	Merge(a, begin1, end1, begin2, end2, tmp);
}

void MergeSort(int* a, int n) {
   //开辟一个tmp数组，在这个数组里进行归并
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL) {
		perror("MergeSort::malloc");
		exit(-1);
	}
	_MergeSort(a, 0, n-1, tmp);
	free(tmp);
}

复杂度分析

 每一趟归并都需要将原数组相邻为h的有序序列进行两两归并，需要将待排序序列中的所有记录扫描一遍，耗费O(N)时间，而由完全二叉树的深度可知，整个归并排序需要进行log2^n次，因此时间复杂度为O(N*logN)，需要另外开辟一块相同大小的数组进行归并以及递归时深度为log2^N的栈空间，因此空间复杂度为O(N+logN)=O(N)。

2.4.2迭代实现归并排序

 非递归的迭代方法，避免了递归时深度为log2^n的栈空间，空间只是用到申请归并临时用的一块数组，因此空间复杂度为O(N)，时间复杂度任为O(N*logN)。所以归并排序时，尽量考虑用非递归方法。

代码实现

void Merge(int* a, int begin1, int end1, int begin2, int end2, int* tmp) {
	int i = begin1;
	int j = begin1;
	while (begin1 <= end1 && begin2 <= end2) {
    //两段区间内的数据挨个比较
		if (a[begin1] < a[begin2]) {
			tmp[i++] = a[begin1++];
		}
		else {
			tmp[i++] = a[begin2++];
		}
	}
    //走到这里说明至少有一个区间没数据了，不知道是哪段区间没数据，需要挨个判断
    //若第一段区间还有数据则全部拷贝到tmp中，说明第二段没有了
	while (begin1 <= end1) {
		tmp[i++] = a[begin1++];
	}
    //若第二段区间还有数据则全部拷贝到tmp中，说明第一段没有了
	while (begin2 <= end2) {
		tmp[i++] = a[begin2++];
	}
    //归并完，再把tmp数组数据拷贝到原数组
	for (; j <= end2; j++)
	{
		a[j] = tmp[j];
	}
}

void MergeSortNonR(int* a, int n) {
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL) {
		perror("MergeSort::malloc");
		exit(-1);
	}
	int gap = 1;
	while (gap < n) {
		for (int i = 0; i <n ; i+=2 * gap) {
			int begin1 = i, end1 = i + gap - 1, 
				begin2 = i + gap, end2 = i + 2 * gap - 1;
			//最后一个小组归并时，第二个小区间不存在，不需要归并了
			if (begin2 >= n)
				break;
			//最后一个小组归并时，第二个小区间存在，但第二个区间不够gap个，需要修正
			if (end2 >= n)
				end2 = n - 1;
			Merge(a, begin1, end1, begin2, end2, tmp);
		}
		gap *= 2;
	}
	free(tmp);
}

 2.5计数排序

基本思想

1. 统计相同元素出现次数
2. 根据统计的结果将序列回收到原来的序列中

对于数据比较大的时候我们可以通过相对映射，让（该值-min）后的数组加一，最后还原回去即可。

动图展示

代码实现

void CountSort(int* a, int n) {
	int i = 0;
	int min = a[0], max = a[0];
	for (i = 0; i < n; i++) {
		if (a[i] < min)
			min = a[i];
		if (a[i] > max)
			max = a[i];
	}
        //计算有几个数需要计数
	int num = max - min + 1;
	int* count = (int*)malloc(sizeof(int) * num);
	if (count == NULL) {
		perror("CountSort::malloc");
		exit(-1);
	}
	memset(count, 0, sizeof(int) * num);
        //相对映射，count数组记录的是，每个元素出现的次数
	for (i = 0; i < n; i++) {
		count[a[i] - min]++;
	}
	int j = 0;
        //将每个元素（可能有若干个相同元素）按从小到大依次拷贝到原数组
	for (i = 0; i < num; i++) {
		while (count[i]--) {
			a[j++] = i + min;
		}
	}
	free(count);
}

复杂度分析

1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
2. 时间复杂度：O(MAX(N,范围))
3. 空间复杂度：O(范围)

3.八大排序对比

3.1性能测试评估

void TestOP()
{
	srand(time(0));
	const int N = 100000;
	int* a1 = (int*)malloc(sizeof(int) * N);
	int* a2 = (int*)malloc(sizeof(int) * N);
	int* a3 = (int*)malloc(sizeof(int) * N);
	int* a4 = (int*)malloc(sizeof(int) * N);
	int* a5 = (int*)malloc(sizeof(int) * N);
	int* a6 = (int*)malloc(sizeof(int) * N);
	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();
		a2[i] = a1[i];
		a3[i] = a1[i];
		a4[i] = a1[i];
		a5[i] = a1[i];
		a6[i] = a1[i];
	}
	int begin1 = clock();
	InsertSort(a1, N);
	int end1 = clock();
	int begin2 = clock();
	ShellSort(a2, N);
	int end2 = clock();
	int begin3 = clock();
	SelectSort(a3, N);
	int end3 = clock();
	int begin4 = clock();
	HeapSort(a4, N);
	int end4 = clock();
	int begin5 = clock();
	QuickSort(a5, 0, N - 1);
	int end5 = clock();
	int begin6 = clock();
	MergeSort(a6, N);
	int end6 = clock();
	printf("InsertSort:%d\n", end1 - begin1);
	printf("ShellSort:%d\n", end2 - begin2);
	printf("SelectSort:%d\n", end3 - begin3);
	printf("HeapSort:%d\n", end4 - begin4);
	printf("QuickSort:%d\n", end5 - begin5);
	printf("MergeSort:%d\n", end6 - begin6);
	free(a1);
	free(a2);
	free(a3);
	free(a4);
	free(a5);
	free(a6);
}
int main()
{
	TestOP();
	return 0;
}

 

3.2排序算法复杂度及稳定性分析

排序算法	平均时间复杂度	最坏时间复杂度	最好时间复杂度	空间复杂度	稳定性
冒泡排序	O(n²)	O(n²)	O(n)	O(1)	稳定
简单选择排序	O(n²)	O(n²)	O(n)	O(1)	不稳定
直接插入排序	O(n²)	O(n²)	O(n)	O(1)	稳定
快速排序	O(nlogn)	O(n²)	O(nlogn)	O(nlogn)	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定
希尔排序	O(nlogn)	O(ns)	O(n)	O(1)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
计数排序	O(n+k)	O(n+k)	O(n+k)	O(n+k)	稳定