拯救我的算法之——快速排序与归并排序

快速排序

快速排序基于分治的思想

主要步骤：

1. 在一个数组中确定分界点：q[l]、q[(l+r)]、q[r]、或者随机一点
2. 调整区间：任取一点x，使得x左边的数都小于等于x，x右边的数都大于等于x
3. 递归处理左右两段

这里第二步尤为值得我们思考：

先给出一种暴力做法：

1. 创建俩个数组 a[]、b[]
2. 将整个区间q[l]-q[r]中的数遍历，如果q[i]<=x,则将q[i]放入a[]：否则，放入b[]
3. 最后将a[]放入q[]，再将b[]放入q[ ]

这种方法虽然简单容易想出来，但是的时间复杂度是O(n)，那么就需要效率更高的方法来提高整个算法的效率。

1. 首先我们确定一点 i ，用 x 开始与 i 位置的数做比较，如果 i 位置的数比 x 小，则 i 这个位置（指针）向左移动，直到遇到比 x 大的数字，则此时 i 停止。
2. 这时从右边确定一点 j 开始向左移动，如果 j 位置的数大于 x ，则继续向左移动，直到遇到小于 x 的数字，此时 j 同样停止移动。
3. i 与 j 对应位置的数互换位置，而 i 与 j 的指针不动。
4. 继续之前的操作，直到 i 与 j 相遇。这样就可以使得这个区间中 x 左边的数都小于等于 x ，x 右边的数都大于等于 x 。

思考：为什么这种方法是正确的？

---

不论在什么时刻，i 左边的数都是小于等于 x 的，因为只有这样指针才会移动，并且如果发生与 j 的调换，也同样如此。同理，j 右边的数都是大于等于 x 的。当 i 与 j 相遇或者穿过时，数组中的所有数就很完美的由 x 分为两部分。

代码演示

#include <iostream>
using namespace std;

const int N = 1e6 + 10;

int n;
int q[N];

void quick_sort(int q[],int l,int r)
{
	//如果只有一个数，则不需要进行排序
	if(l >= r) return;
	//x为我们设定的分界点, q[l]、q[r]、q[(l + r) / 2]都是可以的
	//这里的 i 和 j 要指向边界的两侧。（因为我们在后来的i和j交换完后，指针都要向中间移动一次。那么我们就可以直接在一开始就先向中间移动一次，然后再进行判断，那么我们先将指针指向边界的两侧，在移动完成后才可以指向边界。）
	int x = q[(l+r)/2], i = l - 1, j = r + 1;
	while(i < j)
	{
		do i++; while(q[i] < x);
		do j--; while(q[j] > x);
		if(i < j) swap(q[i],q[j]);
	}
	quick_sort(q, l, j);	
	quick_sort(q, j+1, r);
	//这里也可以写成
	//quick_sort(q, l, i-1);
	//quick_sort(q, i, r);
	//但是注意，如果是这种写法边界点就一定不能取q[l],可以取成q[r],否则会出现边界问题。可以用样例 1，2来推演,出现的结果是[0,1]区间无限递归。（l=0,r=1）
}
int main()
{
	scanf("%d",&n);
	for(int i=0;i<n;i++) scanf("%d",&q[i]);
	
	quick_sort(q,0,n-1);

	for(int i=0;i<n;i++) printf("%d ",q[i]);
	
	return 0;
}

快速排序算法的证明与边界分析
这里附上大佬的讲解

归并排序

归并排序同样是基于分治策略的算法。

具体步骤：

1. 确定分界点：mid = (l+r)/2

2. 递归排序左边和右边

3. 归并 —— 合二为一

   注意这里的分界点与快速排序的分界点的区别 ，这里是整个数组序列的中间位置，而快排的分界点是随机找到的一个数。

这里的重要问题就是第三步，如何将两个有序数组合二为一。

在这两个有序数组中，首先比较两个数组的最小值，假如数组一中的数较小，则将其保存至新数组中的第一个数，然后将数组一中的指针向后移动一位。之后再比较两个指针指向的数，将较小的数存入新数组，然后移动一个指针。重复操作，如果一个数组所有数都存入新数组，而另一个数组还有剩余的数，则将这些剩余的数全部存入新数组。第一个指针扫描的是左边的数组，第二个指针扫描的是右边的数组，因此整个时间复杂度是O(n)。

我们直到归并排序的时间复杂度是O(nlog2n)，但是这是为什么？我们可以用一个图来直观感受以下。

如果要将一个数组无限二分下去直至每个数组都只有一个值，则需要log2N次，而每次扫描需要的时间复杂度为O(n)，一次整个归并排序的时间复杂度为O(nlog2n)。

代码演示

#include<iostream>
using namespace std;

const int N = 1e6+10;
//temp[N]是新创建的数组
int q[N],temp[N];
int n;

void merge_sort(int q[],int l,int r)
{
	//如果只有一个元素，则不需要排序
	if(l>=r) return;
	//mid是整个数组中间的位置
	int mid = (l+r)>>1;
	//将数组分为两部分，左右部分都进行归并排序
	merge_sort(q,l,mid),merge_sort(q,mid+1,r);
	int k = 0,int i = l,int j = mid+1;
	//依次比较指针指向的数，将较小的数放在创建出来的temp[]中
	while(i <= mid && j <= r)
	{
		if(q[i] <= q[j])
			temp[k++] = q[i++];
		else 
			temp[k++] = q[j++];
	}
	//如果一个数组遍历完毕，则将另一个数组中剩余的所有数字都放入temp[]中
	while(i <= mid)
		temp[k++] = q[i++];
	while(j <= r)
		temp[k++] = q[j++];
	//最后将temp[]中的数全部存入q[]中
	for(i=l,j=0;i<=r;i++,j++)
		q[i] = temp[j];
}
int main()
{
	scanf("%d" ,&n);
	for(int i=0;i<n;i++)
	scanf("%d",&q[i])

	merge_sort(q,0,n-1);

	for(int i=0;i<n;i++)
	printf("%d ",q[i]);
	return 0;
}