「数据结构」八大排序2：快排、归并排序

个人主页：Ice_Sugar_7
所属专栏：初阶数据结构
欢迎点赞收藏加关注哦！

快速排序

快排的基本思想是从序列中选某一个元素为key，然后开始多次排序，每次排完后key左边的值都小于key，右边则都大于key。然后对key左右的区间（[begin,key - 1]和[key+1,end]，左右都是闭区间）分别进行递归，划分为更小的区间，直到成为有序区间再返回。最终整个区间就是有序的

所以，快排的递归过程可以看作是一棵二叉树

●每次选择一个基准元素，将小于基准的元素放在左子树，大于基准的元素放在右子树。然后对左子树和右子树分别进行快排。这个过程可以一直递归下去
●直到每个子树只剩下一个或没有元素（即递归到叶子节点）时返回

快排的框架如下：

void QuickSort(int* a, int left, int right) {  //left和right是区间端点（都是闭区间）
	if (right <= left)  //right如果小于left，那么这个区间不存在；right==left说明这个区间只有一个元素
		return;
	int key = PartSort(a, left, right);  //PartSort是找key的函数，下面会讲
	QuickSort(a, left, key - 1);
	QuickSort(a, key + 1, right);
}

快排的核心就是找key，有三种方法找key，下面依次介绍

先解释两个概念：找大和找小：

找大：一直向左走或向右走，直到找出比key大的值，或者找不到
找小：一直向左走或向右走，直到找出比key小的值，或者找不到

霍尔版本

霍尔版本的快排是原始版本，先看动图：

这种方法具体步骤如下：
●假设序列最左边的值为key，让右边（right）先走，找小。
●找到后停下，轮到左边（left）走，找大。找到后停下，交换此时left和right处的元素。
●重复这个过程，直到left和right相遇，交换此时left和key处的值
●到这里，序列以key为分界线，划分左、右两个区间

注意：假设哪边为key，那么一开始就要让另一边先走

int PartSort1(int* a, int left, int right) {
	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[left], &a[keyi]);
	return left;
}

挖坑法

相较于霍尔版，挖坑法的逻辑更好理解

●假设序列最左边的值为key，右边先走，直到遇见比key小的值，就把这个值填入坑中，然后自己成为新的坑
●right走完后，轮到left走，left是遇到比key大的值才停下来。然后同样把这个值扔进坑里，自己成为新的坑
●left和right相遇时，将key填入坑中（此时坑位就是left和right所在位置）

int PartSort2(int* a, int left, int right) {
	int hole = left;
	int tmp = a[hole]; //保存最开始坑位的值
	while (left < right)
	{
		while (left < right && a[right] > tmp)  //相等的话可以不移动，不会死循环
		{
			--right;
		}
		a[hole] = a[right];  //遇到比坑位小的值
		hole = right;  //更新坑位下标

		while (left < right && a[left] < tmp)
		{
			--left;
		}
		a[hole] = a[left];
		hole = left;  //更新坑位
	}
	a[hole] = tmp;
	return hole;
}

前后指针法

●定义两个指针prev、cur，prev一开始位于最左边，cur在prev的下一个位置。让cur开始走，往右找小，如果遇到比key小的值，那就让prev++，然后交换a[prev]和a[cur]
（但如果prev++之后和cur一样的话，那就没必要交换了）

●当cur遇到比key大的值时，此时prev不走，cur照常走
按照这种规律，那prev就会在第一个比key大的值的前面停下来
而cur继续走，再遇到比key小的值时，由于prev++，所以就会将那个小的数和这个大的数交换位置，相当于把大的数和小的数分别甩到后面和前面

●当cur走到最右边时，循环结束，交换prev和key处的值
（此时cur处的值比a[key]小，就把它甩到前面了）

int PartSort3(int* a, int left, int right) {
	int mid = GetMidi(a, left, right); //采用三数取中的方法取中间数，优化快排，下面会讲这种方法
	Swap(&a[left], &a[mid]);
	int key = mid;
	int prev = left, cur = left + 1;
	while (cur <= right)
	{
		if (a[cur] < a[key] && ++prev != cur)  //遇到比key小的值，就++prev，然后若prev和cur不相等，那就交换prev和cur
		{
			Swap(&a[prev], &a[cur]);
		}
		//如果比key大，那cur就继续走
		++cur;
	}
	Swap(&a[prev], &a[key]);
	return prev;
}

---

快排优化

由于快排的递归过程可以看作是二叉树，所以我们可以根据二叉树的特点对快排进行优化，提高其效率

三数取中

对于同样的n个元素，如果二叉树越斜，那么它就越深；而如果二叉树比较平衡，那么深度就比较浅（完全二叉树深度最浅）
前面我们快排取的key要么是最左，要么是最右，如果key处的值刚好是最大值或最小值的话，那对快排是相当不利的
而反之，如果key是序列的中位数，或者是接近中位数（总之就是尽可能不让它成为最值），那就可以极大提高快排的效率
所以写一个三数取中的函数，从left、right和mid（序列中间的那个数）三者中取大小在中间的数，然后把它和left处的值交换，让它成为key

int GetMidi(int* a, int left, int right) {
	int mid = (left + right) / 2;
	if (a[left] > a[right])  //左>右
	{
		if (a[mid] > a[left])
			return left;
		if (a[right] > a[mid])
			return right;
		else
			return mid;
	}
	else  //右>左 
	{
		if (a[left] > a[mid])
			return left;
		if (a[mid] > a[right])
			return right;
		else
			return mid;
	}
}

---

小区间直接插入

对于完全二叉树而言，越往下结点数越多，递归的成本也越来越大
拿常规的快排来说（递归过程比较接近完全二叉树），递归到比较深层次时（此时区间长度相对而言比较小）我们不用快排，转而使用直接插入排序，可以降低时间成本
优化后代码如下：

void QuickSort1(int* a, int left, int right) {
	if (right <= left)
		return;
	if (right - left + 1 <= 10)  //区间长度小于等于10时就采用直接插入排序
		InsertSort(a, right - left + 1); 
	else
	{
		int key = PartSort1(a, left, right);
		QuickSort1(a, left, key - 1);
		QuickSort1(a, key + 1, right);
	}
}

---

非递归快排

当递归层数过深时，就会有栈溢出的风险，此时要使用非递归快排，这种思路通过栈来实现

思路：
●把区间端点下标（左右都是闭区间）入栈，然后出栈，取到端点下标，找key
●由key可以将原区间划分为左、右两个子区间，将这两个区间的端点入栈，然后继续找key，划分区间
●重复上面的步骤，当栈为空时，排序完成

void QuickSortNonR(int* a, int left, int right) {
	Stack st;
	StackInit(&st);
	StackPush(&st, left);  //左端点入栈
	StackPush(&st, right);
	while (!StackEmpty(&st))
	{
		int key = PartSort1(a, left, right);
		right = StackTop(&st);  //取栈顶元素
		StackPop(&st);  //出栈
		left = StackTop(&st);
		StackPop(&st);
		if (left < key - 1)  //区间至少有两个元素才入栈
		{
			StackPush(&st, left);
			StackPush(&st, key - 1);
		}
		if (right > key + 1)  //区间至少有两个元素才入栈
		{
			StackPush(&st, key + 1);
			StackPush(&st, right);
		}
	}
}

你会发现，虽然叫非递归，但是整个过程几乎和递归一模一样

---

归并排序

递归

和快排差不多，也是先分割区间，不过归并排序不用找key，而是直接从中间分割
分割到有序时，将元素从小到大尾插到临时数组tmp。插好后将tmp拷贝到原数组
示意图如下：

void _MergeSort(int* a,int* tmp, int left,int right) {
	if (left >= right)
		return;
	int mid = (left + right) / 2;
	int left1 = left, right1 = mid;  //左区间的左端点、右端点
	int left2 = mid + 1, right2 = right; //右区间的左端点、右端点
	_MergeSort(a, tmp, left1, right1);  //左区间进行排序
	_MergeSort(a, tmp, left2, right2);  //右区间进行排序
	int i = left;  //控制tmp的下标

	//合并有序数组（归并中的“并”）
	while (left1 <= right1 && left2 <= right2)
	{
		if (a[left1] < a[left2])
			tmp[i++] = a[left1++];
		else
			tmp[i++] = a[left2++];
	}
	//确保剩下的元素都进tmp
	while (left1 <= right1)
	{
		tmp[i++] = a[left1++];
	}
	while (left2 <= right2)
	{
		tmp[i++] = a[left2++];
	}
	memcpy(a + left, tmp + left, sizeof(int) * (right - left + 1));
}

void MergeSort(int* a,int n) {
	int left = 0;
	int right = n - 1;
	int mid = (left + right) / 2;
	int* tmp = (int*)malloc(sizeof(int) * n);
	_MergeSort(a, tmp,left,right);
	free(tmp);
}

非递归

将序列中的元素先合并为两个（1,1合并），然后两个两个合并为四个（2,2合并），再合并为八个……
使用非递归的话需要注意边界，因为每次是按2的倍数进行合并的，但是数据不一定是二的倍数，所以要对右区间的长度进行判断：
●如果右区间左端点已经比n大了，那说明右区间不存在，那就不用归并
●如果只有右区间右端点越界，那就把它修改为（n-1）

最后的memcpy也要注意，因为可能越界，所以不能直接拷贝2*gap个整型大小的空间

void MergeSortNonR(int* a, int n) {
	int* tmp = (int*)malloc(sizeof(int) * n);
	int gap = 1;  //每个区间的长度
	while (gap < n)
	{
		int index = 0;  //临时数组的下标
		for (int i = 0; i < n; i += 2 * gap)  //对每一组进行归并
		{
			int left1 = i;  //左区间左端点
			int right1 = left1 + gap - 1;  //左区间右端点
			int left2 = left1 + gap;  //右区间左端点
			int right2 = left1 + 2 * gap - 1;  //右区间右端点
			if (left2 >= n)  //如果右区间的左端点都超出数组范围了，说明右区间不存在
				break;
			if (right2 >= n)  //如果右区间右端点越界，那就对它进行修正
				right2 = n - 1;

			//放进临时数组
			while (left1 <= right1 && left2 <= right2)
			{
				if (a[left1] < a[left2])
					tmp[index++] = a[left1++];
				else
					tmp[index++] = a[left2++];
			}
			//确保剩余元素进入数组
			while (left1 <= right1)
			{
				tmp[index++] = a[left1++];
			}
			while (left2 <= right2)
			{
				tmp[index++] = a[left2++];
			}
			memcpy(a + i, tmp + i, sizeof(int) *(right2 - i + 1));
		}
		gap *= 2;
	}
	free(tmp);
}

---

计数排序（了解即可）

额外开一个空间tmp，并初始化为0。遍历序列，遇到某个数，就让额外空间下标对应的元素+1。其实就相当于一块计数板，记录相应的数出现的次数

这么说确实挺抽象的，举个栗子
比如6，1，7，3，9，2，4，6，从6开始遍历：

原理很简单：tmp相当于有序序列，遍历完原序列后我们遍历tmp，遇到出现次数不为0的就打印它的下标，出现几次就打印几次，也就可以打印出有序序列了

使用计数排序要先找出序列的最大值、最小值，才能确定tmp下标的范围。比如一个序列最小是100，最大是199，但是数组下标是从0开始的，直接建大小为200的tmp显然浪费空间，所以我们不一定说下标要和数对应，比如0对0,1对1这样子，我们可以0对100,1对101（这种转换数学中称为“映射”）

void CountSort(int* a, int n)
{
	int min = a[0], max = a[0];
	for (size_t 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);
	printf("range:%d\n", range);
	if (count == NULL)
	{
		perror("malloc fail");
		return;
	}
	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;
		}
	}
}