[数据结构]八大排序算法总结


// 插入排序
void InsertSort(int* a, int n)
{
	for (int j = 0; j < n; ++j)
	{
		int end = j;
		int tmp = a[end];
		while (end > 0)
		{
			if (tmp < a[end - 1])
			{
				a[end] = a[end - 1];
				--end;
			}
			else
			{
				break;
			}
		}
		a[end] = tmp;
	}	
}

直接插入排序的特性总结：

元素集合越接近有序，直接插入排序算法的时间效率越高
时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定。(我们可以控制相等时，插入在前一个的后面保持其相对顺序不变)

2.2 希尔排序

2.2.1 基本思想

希尔排序又称为缩小增量排序法，其基本思想如下：

先选定一个整数，把待排序文件中所有的记录分组，所有距离为gap的记录分在同一组内，并对每一组内的记录进行排序；然后，取重复上述分组和排序的工作。当达到gap = 1时，所有记录在同一组内排好序。

希尔排序的步骤：

预排序，其目的是：使数据接近有序
直接插入排序

gap的影响：

gap越大，数据跳的越快；
gap越小，数据跳的越慢
gap等于1，相当于直接插入排序。

2.2.2 代码实现


// 希尔排序
void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		for (int i = 0; i < n - gap; ++i)
		{
			int end = i;
			int 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>1时都是预排序，目的是让数组更接近于有序。当gap==1时，数组已经是接近有序的了，这样就会很快。整体而言，可以达到优化的效果。
希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算；

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

因为咋们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：O(N^1.25) ~ O(1.6*N*1.25)。

4.稳定性：不稳定

2.3 直接选择排序

2.3.1 基本思想

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

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

2.3.2 代码实现


// 直接选择排序
void SelectSort(int* a, int n)
{
	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		int max = begin; 
		int min = begin;
		int i = begin;
		while (i <= end)
		{
			if (a[i] > a[max]) //找最大
			{
				max = i;
			}
 
			if (a[i] < a[min])//找最小
			{
				min = i;
			}
			++i;
		}
		
        //交换
		Swap(&a[begin], &a[min]);
		if (max == begin) 
		{
			max = min;
		}
		Swap(&a[end], &a[max]);
		++begin;
		--end;
	}	
}

直接选择排序特性总结：

直接选择排序思想非常好理解，但是效率很低，实际中很少使用；
时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：不稳定

2.4 堆排序

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

关于堆排序的详细思路及其实现，请看 👉[数据结构]二叉树之堆的实现


//交换
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
 
//向下调整算法
void AdjustDown(int* a, int n, int parent)
{
	int minchild = parent * 2 + 1;
 
	while (minchild < n)
	{
		//选出较小的孩子
		if (minchild + 1 < n && a[minchild] < a[minchild + 1])
		{
			++minchild;
		}
 
		if (a[minchild] > a[parent])
		{
			Swap(&a[minchild], &a[parent]); //交换
 
			//迭代
			parent = minchild;
			minchild = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
 
//堆排序
void HeapSort(int* a, int n)
{
	//向下调整建堆
	for(int i = (n - 2) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}
 
	//选数
	int i = 1;
	while (i < n)
	{
		Swap(&a[0], &a[n - i]);
		AdjustDown(a, n - i, 0);
		++i;
	}
}

堆排序特性总结：

堆排序使用堆来选数，效率高了很多；
时间复杂度：O(N*logN)
时间复杂度：O(1)
稳定性：不稳定

2.5 冒泡排序

2.5.1 排序思想

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

在这里插入图片描述

2.5.2 代码实现


// 冒泡排序
void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n; ++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)
		{
			break;
		}
	}

冒泡排序特性总结：

冒泡排序是一种非常容易理解的排序；
时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定

2.6 快速排序

2.6.1 基本思想

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法。其基本思想为：

任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

2.6.2 快排递归主要框架


// 假设按照升序对array数组中[left, right)区间中的元素进行排序
void QuickSort(int* a, int left, int right)
{
	if (right <= left)
	{
		return;
	}
 
 
	int key = PartSort3(a, left, right);
 
	QuickSort(a, left, key - 1);  //左
	QuickSort(a, key + 1, right); //右
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像。

2.6.3 hoare版本

思路：

取左右边界和中间值作为基准值放在左边界，然后从右边界right开始找小于基准值的元素；找到之后，从左边界left开始找大于基准值的元素，找到了交换左右两边找到的元素；重复上述步骤，直到 left 和 right 相遇。

注意：left为基准值，right先走。


// 快速排序递归实现
// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{
	int mid = GetMidIndex(a, left, right); //三数取中
	int key = left;
	Swap(&a[key], &a[mid]);
	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[right], &a[key]);
	return right;
}

两个快速排序的优化方法

1.三数取中

假设对一组数据排升序，那么需要给出一个基准值也就是key,然后经过一趟排序后，大于key的在右边，小于key的在左边；通过hoare版本可以发现，我们一般以左边第一个或者右边第一个为基准值，那么就存在最坏的情况也就是每次都选到最小的，此时快排退化成时间复杂度为O(N^2)的排序；

所以为了解决上述问题，我们需要优化一下快排。

三数取中：通过取左、右边界和中间这三个值进行比较取出中间值作为基准值并把其放在left(right)处。


//三数取中
int GetMidIndex(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] > a[mid])
	{
		if (a[right] > a[left])
		{
			return left;
		}
		else if (a[mid] > a[right])
		{
			return mid;
		}
		else
		{
			return right;
		}
	}
	else //a[left] < a[mid] < a[]
	{
		if (a[left] > a[right])
		{
			return left;
		}
		else if (a[right] > a[mid])
		{
			return mid;
		}
		else
		{
			return right;
		}
	}
}

2.递归到小的子区间时，可以考虑使用插入排序

在快排当中，递归越深子区间越接近有序，并且递归越深排序趟数越多；我们知道快速排序递归类似一棵二叉树，如下图：

可以看到在快速排序中最后三层占据了主要的排序时间；当快排递归越深，数据越接近有序；而当数据越趋近于有序时，插入排序的时间复杂度越接近O(N)，所以此时使用插入排序起到优化的效果。


void QuickSort(int* a, int left, int right)
{
	if (right <= left)
	{
		return;
	}
 
	if (right - left <= 8)  //小区间优化，可以自行取值
	{
		InsertSort(a+left, right-left+1);
	}
	else
	{
		int key = PartSort3(a, left, right);
 
		QuickSort(a, left, key - 1);
		QuickSort(a, key + 1, right);
	}
	
}

2.6.4 挖坑法

思路：

取左右边界和中间值作为基准值放在左边界，将基准值取出保存起来并把元素位置标记为hole；同样开始从右边界right开始找小，找到了把值放入hole位置中并将此时的right赋值给hole；再从左边开始找大，找到了把值放入hole中并将此时的left赋值给hole;重复上述步骤，直到left和right相遇。

注意：left为基准值，right先走。


// 快速排序挖坑法
int PartSort2(int* a, int left, int right)
{
	int mid = GetMidIndex(a, left, right);
	Swap(&a[left], &a[mid]);
	int key = a[left];
	int hole = left;
 
	while (left < right)
	{
		while (left < right && key <= a[right])
		{
			--right;
		}
		a[hole] = a[right];
		hole = right;
 
		while (left < right && key >= a[left])
		{
			++left;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = key;
	return hole;
}

2.6.5 前后指针法

思路：

确定一个中值（利用三数取中）为基准值key并将其放在左边界，给出两个指针prev和cur开始都处于基准值的位置上；cur指针先走，如果cur位置元素大于key则++cur；如果cur位置元素小于key，则++cur和++prev，并且交换cur和prev位置上的元素，直到cur走到右边界结束。


// 快速排序前后指针法
int PartSort3(int* a, int left, int right)
{
	int mid = GetMidIndex(a, left, right);
	Swap(&a[left], &a[mid]);
	int keyi = left;
 
	int prev = left; //前指针
	int cur = left;  //后指针
	while (cur < right)
	{
		++cur;
		if (a[cur] < a[keyi])
		{
			++prev;
			Swap(&a[prev], &a[cur]);
		}
	}
	Swap(&a[prev], &a[keyi]);
	return prev;
}

2.6.6 快速排序非递归

快速排序非递归需要利用数据结构的栈实现；队列代码请看👉CSDN排序算法。

思路：

快排的非递归主要是依靠数据结构栈的特性即先入后出，模拟递归调用的过程；在实际操作过程中，就是在控制一段范围。

注意：取左右区间如果先右后左，入左右区间就应该先左后右。


//快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
{
	Stack st;
	StackInit(&st);
	StackPush(&st, left);
	StackPush(&st, right);
 
	while (!StackEmpty(&st))
	{
        //先右
		int right = StackTop(&st);
		StackPop(&st);
        //后左
		int left = StackTop(&st);
		StackPop(&st);
 
		if (left >= right)
		{
			continue;
		}
 
		int keyi = PartSort2(a, left, right);
		//[left, keyi-1] keyi [keyi+1, right]
 
		if (keyi + 1 < right)
		{
			StackPush(&st, keyi + 1);//先左
			StackPush(&st, right);//后右
		}
 
		if (left < keyi - 1)
		{
			StackPush(&st, left);//先左
			StackPush(&st, keyi - 1);//后右
		}
	}
	StackDestroy(&st);
}

2.6.7 快速排序特性总结

快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序。
时间复杂度：O(N*logN)
空间复杂度：O(logN)
稳定性：不稳定

2.7 归并排序

2.7.1 基本思想

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

动图演示：

2.7.2 递归代码实现


void _MergeSort(int* a, int begin, int end, int* tmp)
{
	if (begin >= end)
	{
		return;
	}
 
	int mid = (begin + end) / 2;
 
	int begin1 = begin, end1 = mid;   //左
	int begin2 = mid + 1, end2 = end; //右
 
	_MergeSort(a, begin1, end1, tmp);//递归左区间
	_MergeSort(a, begin2, end2, tmp);//递归右区间
 
	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, (end-begin+1)*sizeof(int));
}
 
//归并排序递归实现
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (NULL == tmp)
	{
		perror("malloc fail");
		exit(-1);
	}
 
	_MergeSort(a, 0, n-1, tmp);
 
	free(tmp);
	tmp = NULL;
}

归并排序的特性总结:

1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。

2. 时间复杂度：O(N*logN)

3. 空间复杂度：O(N)

4. 稳定性：稳定

2.7.3 非递归代码实现

非递归不需要使用其它的数据结构，通过控制区间的范围实现两两归并，如下图：

上述属于特殊情况，数据个数刚好是2的次方个。

情况1：第一组范围部分越界

首先归并是两两归并，那么第一组范围越界只能是右边界越界(左边界越界不会归并)，且第一组部分越界则第二组全部越界；因为第二组数据不存在所以此时不需要再归并，直接break跳出当前循环。

情况2：第二组范围全部越界

第二组范围全部越界时，第二组范围中的数据不存在所以不需要再归并了，直接break跳出当前循环即可。

情况3：第二组范围部分越界

当第二组范围部分越界(只能是右边界)时，需要注意此时需要修正其右边界。如果不修正，用来存放数据的数组中的值不会被覆盖是随机的，最后拷贝的是该数组中的随机数。


//归并排序非递归实现
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (NULL == tmp)
	{
		perror("malloc fail");
		exit(-1);
	}
 
	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2*gap)
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
 
			//第一组部分越界
			if (end1 >= n)
			{
				break;
			}
 
			//第二组全部越界
			if (begin2 >= n)
			{
				break;
			}
 
			//第二组部分越界
			if (end2 >= n)
			{
				end2 = n - 1;
			}
			int j = i;
			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, (end2 - i + 1) * sizeof(int));
		}
		gap *= 2;
	}
 
	free(tmp);
	tmp = NULL;
}

2.8 计数排序

2.8.1 基本思想

思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

操作步骤：

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

绝对映射：

新数组开辟空间为数组中最大元素的(max+1),然后遍历数组，将原数组每个整型出现的次数映射到新数组当中。

相对映射：

新数组开辟空间为原数组中[ max(最大) - min(最小) + 1 ],遍历数组，将原数组每个整型出现的次数映射到新数组当中的相对位置上。

动图演示：

2.8.2 代码实现


// 计数排序
void CountSort(int* a, int n)
{
	int max = a[0];
	int min = a[0];
	int i = 0;
	while (i < n)
	{
		if (max < a[i]) //找最大
		{
			max = a[i];
		}
		if (min > a[i]) //找最小
		{
			min = a[i];
		}
		++i;
	}
    
    //相对映射
	int* arr = (int*)malloc((max - min + 1)*sizeof(int));
	if (NULL == arr)
	{
		perror("malloc fail");
		exit(-1);
	}
	memset(arr, 0, (max - min + 1) * sizeof(int));
 
    //计数
	for (int j = 0; j < n; ++j)
	{
		++arr[a[j] - min];
	}
    
   
	i = 0;
	for (int j = 0; j < (max - min + 1); ++j)
	{
		while (arr[j])
		{
			a[i++] = min + j;
			--arr[j];
		}
	}
	free(arr);
	arr = NULL;
}

计数排序的特性总结：

1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。

2. 计数排序只能排序整型，其它类型不适用。

3. 时间复杂度：O(MAX(N,范围))

4. 空间复杂度：O(范围)

5. 稳定性：稳定

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

排序方法	最好情况	最坏情况	辅助空间	稳定性
冒泡排序	O(N)	O(N^2)	O(1)	稳定
简单选择排序	O(N^2)	O(N^2)	O(1)	不稳定
直接插入排序	O(N)	O(N^2)	O(1)	稳定
希尔排序	O(N^1.3)	O(N^2)	O(1)	不稳定
堆排序	O(N*logN)	O(N*logN)	O(1)	不稳定
归并排序	O(N*logN)	O(N*logN)	O(N)	稳定
快速排序	O(N*logN)	O(N*logN)	O(N) \|\| O(logN)	不稳定

相关阅读:
Web3.0时代的全新合作模式：DAO
【Leetcode】478. Generate Random Point in a Circle（配数学证明）
Vim插件 YouCompleteMe 安装
 Fabric.js 设置容器类名要注意这几点
 mac下如何简单粗暴使用Python进行网络爬虫（2）
python小题
 JAVA-OO_实验03_继承（三峡大学）
Golang 接口（interface）最佳实践
 16位简单ASM题的记录——[HGAME 2022 week1]easyasm
【网络通信】浅析UDP与TCP协议的奥秘
原文地址：https://blog.csdn.net/qq_59456417/article/details/127932839