AcWing笔记：01基础算法：快速排序+归并排序（例题详解）

AcWing学习网站：AcWing一个专属于程序员的平台，为大家在漫漫的刷题之旅中，提供最优质的解答https://www.acwing.com/about/

快速排序

基本思想：分治思想

过程：先排序再递归

算法模版：

quick_sort(int q[], int l,int r){
    if(l>=r) return；//也可以写等于==
    int i = l - 1, j = r + 1, x = a[l + r >> 1];
    while(i<j){
        do i++; while(a[i] < 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);
}

易错点：

1、i 和 j 的取值要取到左边界的左一个，右边界的右一个

原因：在后面遍历数组判断是否小于或者大于x的时候，使用的do while语句，即边界先加一减一再进行判断。

2、不清楚为什么swap就可以实现最后的有序？

原因：可以思考一下递归到只有一个数字的时候，对于一个数字，我们可以当成是有序的，然后回溯到两个数字、三个三个数字的时候，此时意义其实就是将比x小的放一边，比x大的放一边，我找到了一个比较可以解释这个说法的用例：4、1、2、3、5，你们可以尤其关注一下4的位置以及变量 j 指向的位置。

3、数组的变化是实时的！影响每一次递归。

例题：

 

我在做这一题的时候思想非常的死板，直接对数组进行了快排，然后输出第k个数字，明显这在算法复杂度上是不占优势的，而真正快速的做法是在快排的时候，缩小排序范围，只在符合条件的那一边进行排序，最后 l 和 r 都会指向答案的那个数，任意输出一个即可。

#include<iostream>
using namespace std;
const int N = 1e5+10;
int a[N];
int quick_sort(int a[],int l,int r,int k){
    if(l>=r) return a[l];
    int i = l-1,j = r+1,x = a[(l+r)>>1];
    while(i<j){
        do i++; while(a[i]<x);
        do j--; while(a[j]>x);
        if(i<j) swap(a[i],a[j]);
    }
    if(j-l+1>=k) quick_sort(a,l,j,k);
    else quick_sort(a,j+1,r,k-(j-l+1));
}

int main(){
    int n,k;
    cin>>n>>k;
    for(int i=0;i<n;i++) scanf("%d",&a[i]);
    cout<<quick_sort(a,0,n-1,k);
    return 0;
}

上面是以长度来区分的，也可以直接用下标来区分:

#include <iostream>
using namespace std;
const int N = 100010;
int n, k;
int q[N];

int quick_sort(int l, int r, int k) 
{
    if (l >= r) return q[l];
    int x = q[l + r >> 1];
    int 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]);
    }
    if (k <= j) return quick_sort(l, j, k);
    return quick_sort(j + 1, r, k);
}

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

归并排序

基本思想：分治思想

过程：先递归再排序

算法模版：

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

    for(int i = l,j = 0;i <= r;i++,j++) a[i] = tmp[j];
}

易错点：

1、先递归再排序，和快排的先排序再递归不同

2、注意最后两个while的作用，如果有一边没有全部插入到tmp，就全部接上。

3、注意最后tmp的下标关系和a的下标关系，a的下标关系是原数组的具体位置，而tmp每一次都是从0开始，所以最后把正确顺序赋值给a的时候，a从 l ，也就是具体位置开始，tmp一个个赋值。

4、数组的变化是实时的！影响每一次递归。

例题：

 归并排序的本质是排序，只要第一边排好序了，这边的当前最小值如果是第二边某一个数的逆序对，那第一边最小数之后的数字都是这个数的逆序对。

#include <iostream>

using namespace std;

typedef long long LL;

const int N = 1e5 + 10;

int a[N], tmp[N];

LL merge_sort(int q[], int l, int r)
{
    if (l >= r) return 0;

    int mid = l + r >> 1;

    LL res = 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
        {
            res += mid - i + 1;
            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];

    return res;
}

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);

    cout << merge_sort(a, 0, n - 1) << endl;

    return 0;
}