快速排序与归并排序

前言

今天登录博客发现草稿箱里几篇大一初学时期的写的博客，以初学者视角写的博客，也比较稚嫩了

一、快速排序

快速排序是基于分治思想的一种优雅而简单的排序方法

其基本操作过程可简单分为三步：

1.确定分界点 x：q[ l ]，q[ r ]，q[$\frac{l+r}{2}$]等可随意选取

2.调整区间：使得以分界点为界将区间分为两段，左段区间均小于 x，右段区间均大于 x。

3.递归：使用递归同时处理左右两段

以下列数组为例：

6 4 3 7 2 5 8

（1）首先确定分界点 x = 6（以左端点为例）
（2）设置左右两个指针 i，j，分别指在左右两端

6 4 3 7 2 5 8
i           j

首先开始移动左指针至到大于 x 的数字停下，然后移动右指针到小于 x 的数字停下

6 4 3 7 2 5 8
i         j

交换两个指针所指的数字，同时左右指针向中间移动一次

5 4 3 7 2 6 8
  i     j

重复上述步骤，直到左右指针相遇

5 4 3 7 2 6 8
      i j

5 4 3 2 7 6 8
      j i

至此，可见，左指针前面数字均小于分界点，右指针后面的数字均大于分界点，调整区间就完成了

（3）使用递归，分别处理左右两段数组，即可实现排序。

快速排序模板：

void quick_sort(int q[], int l, int r) {
    if (l >= r) return;  //递归边界 
    int x = q[l], i = l - 1, j = r + 1;  //定义初始化分界点和左右指针 
    while (i < j) {
        while (q[++i] < x);    //移动左右指针 
        while (q[--j] > x);
        if (i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j);      //递归处理左右两段 
    quick_sort(q, j + 1, r);
}

需要特别注意的是：快速排序中含有较多边界问题，需要特别注意，如：

1）当交换左右指针所指数字时，指针要同时向中间移动，因此指针的移动采用前缀自增与自减，所以初始化左右指针时，指针所指的位置要向两边扩一个长度。

2）递归处理时，要注意分界点来选取边界，理论上来讲，边界选取 i 或者 j 均是可以的，但是如果分界点为q[ l ]，边界选用 i 时则会陷入死循环，所以需要特别注意的是：

当分界点选用的是q[ l ] 时，递归的边界要用右指针

同理，当分界点选用的是q[ r ] 时，递归的边界要用左指针

3）值得一提的是，当使用快速排序出现TLE情况时，可将分界点定为q[$\frac{l+r}{2}$]，可减少输入数组为升序或者降序的时间复杂度。

二、归并排序

归并排序同样是基于分治的思想，如何优雅的进行归并排序呢？
其主要过程也可简单分为三步：

1.确定分界点：mid = q[$\frac{l+r}{2}$]

不同于快速排序，归并排序的分界点为其中点，不可随意选取

2.递归排序：将分界点为界的左右两段递归排好顺序。

3.归并，合二为一：将排好序的两段数组一一比较，依次放入辅助数组中，完成排序

以下列数组为例：

6 4 3 7 2 5 8 

（1）首先确定分界点 mid = 7（取数组中间数字）
（2）将左右两段进行递归排序，可得到下列两个分数组：

l:3 4 6 7
r:2 5 8

（3）设置左右两个指针，分别指向两个分数组的开头，并开始比较两个指针所指数字的大小，放在辅助数组中

l:3 4 6 7
  i
r:2 5 8
  j
tmp:2

l:3 4 6 7
  i
r:2 5 8
    j
tmp:2 3

l:3 4 6 7
    i
r:2 5 8
    j
tmp:2 3 4

l:3 4 6 7
      i
r:2 5 8
    j
tmp:2 3 4 5

l:3 4 6 7
      i
r:2 5 8
      j
tmp:2 3 4 5 6

l:3 4 6 7
        i
r:2 5 8
      j
tmp:2 3 4 5 6 7 8

将辅助数组中的数字排序复制在原数组中，排序完成。

归并排序模板：

int tmp[N];
void merge_sort(int q[], int l, int r) {
    if (l >= r) return;    //递归边界条件

    int mid = l + r >> 1;    //确定分界点
    merge_sort(q, l, mid), merge_sort(q, mid + 1, r);  //递归排序

    int k = 0, i = l, j = mid + 1;
    while (i <= mid && j <= r)     //两分数组数值比较
        if (q[i] <= q[j]) tmp[k++] = q[i++];
        else tmp[k++] = q[j++];
        
    while (i <= mid) tmp[k++] = q[i++];  //若有一个分数组提前结束，将另一个分数组后续部分接在辅助数组中
    while (j <= r) tmp[k++] = q[j++];

    for (i = l, j = 0; i <= r; i++, j++)  //将辅助数组排好的数字复制在原数组中
        q[i] = tmp[j];
}

例题 ： 第 k 个数（模板题）

题目：给定一个长度为 n 的整数数列，以及一个整数 k，请用快速选择算法求出数列从小到大排序后的第 k 个数。

输入格式：

第一行包含两个整数 n 和 k。

第二行包含 n 个整数（所有整数均在 1∼109 范围内），表示整数数列。

输出格式：
输出一个整数，表示数列的第 k 小数。

数据范围：
1≤n≤100000,
1≤k≤n

输入样例：

5 3
2 4 1 5 3

输出样例：

3

AC代码：
归并排序：

#include<iostream>
using namespace std;

const int maxn = 100000 + 10;
int q[maxn], tmp[maxn];

void merge_sort(int q[], int l, int r) {
    
    if (l >= r) return;
    
    int mid = l + r >> 1;
    merge_sort(q, l, mid), merge_sort(q, mid + 1, r);
    
    int i = l, j = mid + 1, k = 1;
    while (i <= mid && j <= r)
        if (q[i] <= q[j]) tmp[k++] = q[i++];
        else tmp[k++] = q[j++];

    while (i <= mid) tmp[k++] = q[i++];
    while (j <= r) tmp[k++] = q[j++];

    for (int i = l, j = 1; i <= r; i++, j++)
        q[i] = tmp[j];

}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    for (int i = 1; i <= n; i++) scanf("%d", &q[i]);
    merge_sort(q, 1, n);
    printf("%d", q[k]);
}

快速排序：

#include<iostream>
using namespace std;

const int maxn = 100000 + 10;
int q[maxn], tmp[maxn];

void quick_sort(int q[], int l, int r) {

    if (l >= r) return;

    int x = q[l + r >> 1], i = l - 1, j = r + 1;
    while (i < j) {
        while (q[++i] < x);
        while (q[--j] > x);
        if (i < j) swap(q[i], q[j]);
    }

    quick_sort(q, l, j), quick_sort(q, j + 1, r);
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    for (int i = 1; i <= n; i++) scanf("%d", &q[i]);
    quick_sort(q, 1, n);
    printf("%d", q[k]);
}