归并排序和快速排序

1、归并排序

基于分治法思想，需要递归，并且在每次递归时合并数组

分界点：mid=(l+r)/2

伪代码：
1.将数组分割为2个局部数组，每个数组长度为n/2
2.对两个局部数组分别递归
3.将两个排序完毕的局部数组合并为一个数组tmp
4.扫尾，从tmp数组复制回去

时间复杂度：$O(nlogn)$

归并排序是稳定排序算法

数组合并思想
开一个临时数组tmp，指针i指向数组p，指针j指向数组q，比较p[i]和q[j]，谁小就把元素放到数据tmp（从小到大排序），然后指针向后移，继续比较…

代码：

const int N = 100001;
int A[N], t[N];
void merge_sort(int A[], int l, int r)
{
	if (l >= r)
		return;

	// 将数组分割为2个局部数组
	int mid = l + r >> 1;
	// 递归处理两个局部数组
	merge_sort(A, l, mid);
	merge_sort(A, mid + 1, r);
	// 合并两个局部数组
	int i = l;
	int j = mid + 1;
	int k = 0;
	while (i <= mid && j <= r)
	{
		if (A[i] < A[j])
		{
			t[k++] = A[i++];
		}
		else
		{
			t[k++] = A[j++];
		}
	}
	while (i <= mid)
	{
		t[k++] = A[i++];
	}
	while (j <= r)
	{
		t[k++] = A[j++];
	}
	// 从tmp数组复制回原数组
	for (int i = l, j = 0; i <= r; i++, j++)
	{
		A[i] = t[j];
	}
}

2、快速排序

基于分治法，需要递归，每次递归时需要找一个枢轴

伪代码：
1、随机确定分界点，比如：L[l]、L[(l+r)/2]、L[r]
2、调整区间，以L[l]为基准，使得所有<=L[l]的元素都在L[l]的左边，所有>=L[l]的元素都在L[l]的右边
3、递归处理左右两端，直至每部分内只有一个元素或空为止，即所有元素放在了其最终位置上

时间复杂度：$O(nlogn)$

快速排序是不稳定排序算法

// 从小到大排序
void quick_sort(int a[], int l, int r)
{
	// 出口条件
	if (l >= r)
	{
		return;
	}
	// 确定分界点(l + r)/2
	int x = a[l + r >> 1];
	int i = l - 1;
	int j = r + 1;
	while (i < j)
	{
		// 在x的左边找到一个>x的数
		do {
			i++;
		} while (a[i] < x);

		// 在x的右边找到一个<x的数
		do {
			j--;
		} while (a[j] > x);
		// 交换位置
		if (i < j)
		{
			swap(a[i], a[j]);
		}
	}
	// 递归处理左右两端
	quick_sort(a, l, j);
	quick_sort(a, j + 1, r);
}