算法1（快速排序，快速选择排序，归并排序）

归并排序（分治思想）

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

2. 递归排序left,right

3. 归并——合二为一

一个排序算法是稳定的，并不是说时间效率是稳定的，而是指：如果两个序列当中有两个数值是相同的，排完序之后，他们的位置如果不发生变化，那么这个排序是稳定的，如果它的位置可能发生变化，则排序是不稳定的（没什么卵用，但考试的时候有）

在递归排序的时候，分成的子序列是一步一步合并的，是从长度为一的子序列开始合并的，之后每一步的子序列都是有序的

原数组先被分成左右两半，左边先进入递归，因为左边元素没有达到只有一个，于是再被分成左右两半，依旧是左边先进入递归，到最后只有一个时，该数是最左边的（即原数组下标未0）（记为第logn层左递归）被return ,作为左边数组，然后右边进入递归（因为左边只有一个，被分成两半，所以右边也只有一个）（记为第logn层右递归），然后被return，作为右边数组，然后左右数组排序，排完序后作为logn-1层左递归（数组元素只有2个），进入右递归，分成2个，左return，右return，合并，然后第logn-1层排序，在然后。。。请看VCR：归并排序动画演示哔哩哔哩bilibili

记得放慢观看

void merge_sort(int q[], int l, int r)
{
	//当数组元素只有一个或没有是，返回
	if (l >= r) return;
	//mid=(l+r)/2
	int mid = l + r >> 1;

	//递归排序左右两边，直到两个数组元素都只有一个时，被return回来，按下面的方法进行排序
	merge_sort(q, l, mid), merge_sort(q, mid + 1, r);

	//i为左指针，j为右指针，mid 和 mid+1 为上一递归时提供的左右边界
	int k = 0, i = l, j = mid + 1;
	//循环比较，直到一个数组率先用尽
	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++];

	//将加入排序的数
	for (i = l, j = 0; i <= r; i++, j++) q[i] = temp[j];
}

快速排序

先取分治点x，所有小于x的放左边，所有大于x的放右边，左右递归，单个被return，两个数比较p排序，然后以此类推

void quick_sort(int q[],int l,int r)
{
    if(l>=r) return;
    int x=q[(l+r)/2],i=l-1,r=r+1;
    //或x=q[l]或x=q[r]
    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);
}

快速选择排序

前面和快排类似，后面是专门选一个区间排序

int q[N],k;
int quick_sort(int l,int r,int k)
{
    if(l==r) return q[l];
    int x=q[(l+r)/2],i=l-1,j=r+1;
    while(i<j)
    {
        do i++;whule(q[i]<x);
        do j--;while(q[j]>=x);
        if(i<j) swap(q[i],q[j]);
    }
    //循环结束后，i==j，且q[i]==q[j]==x
    //l=========ixj========r左边长为j-l+1
    int sl=j-l+1;
    if(k<=sl) return quick_sort(l,j,k);
    return quick_sort(j+1,r,k-sl);
}