归并排序与快排(附例题)

归并排序：

算法描述

归并操作的工作原理如下：

1. 申请空间，使其大小为两个已经排序好的序列的空间之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置，重复第三步直到某一指针超出序列尾
4. 将另一序列剩下的所有元素直接复制到合并序列尾

代码

void dic(int l,int r){//dichotomy:二分法
    int mid=(l+r)>>1;//右移一位 
    if(l<r){
        dic(l,mid);
        dic(mid+1,r);
    } 
    merge(l,mid,r);
}
int b[maxn];//设为全局
void merge(int l,int mid,int r){
    int p1=l,p2=mid+1;//p:point
    for(int i=l;i<=r;i++){
        if( (p1<=mid) && ( (p2>r) || (a[p1]<=a[p2]) ) )//求逆序对的话必须要a[p1]<=a[p2] 
            b[i]=a[p1++];
        else
            b[i]=a[p2++];
    }
    for(int i=l;i<=r;i++)a[i]=b[i];
}

注意：

实际写的时候，如果样例多的话，$b[maxn]$一定要写在$merge()$外面，不然很可能T掉

两者对比如图（上面的是写在函数外面的情况）

归并典例

7622:求排列的逆序数

思路：

在归并过程中，当右半部分某个$P_2$位置的数比左边某个$P_1$位置的数小时，$P_2$位置的数要被放到临时数组b中，这就是累积逆序数的时机：
$$sum+=(mid-P_1+1)$$

解释：

求逆序数等价为把右边小的数不断往左放，累计中间跳跃的数的个数，注意： 右边$P_2$位置的数 比 从左边$P_1$位置往后一直到mid位置的所有数都小，比从mid+1位置往后一直到$P_2-1$位置的所有数都大

#include<bits/stdc++.h>
const int maxn=100005;
using namespace std;
int n;
int a[maxn],b[maxn];
long long sum;
void merge(int l,int mid,int r){
    int p1=l,p2=mid+1;//p:point
    for(int i=l;i<=r;i++){
        if( (p1<=mid) && ( (p2>r) || (a[p1]<=a[p2]) ) )//求逆序对的话必须要a[p1]<=a[p2] 
            b[i]=a[p1++];
        else
            b[i]=a[p2++],sum+=(mid-p1+1);//因为是p2移到p1~mid前面 
    }
    for(int i=l;i<=r;i++)a[i]=b[i];
}
void dic(int l,int r){//dichotomy:二分法
    int mid=(l+r)>>1;//右移一位 
    if(l<r){
        dic(l,mid);
        dic(mid+1,r);
    } 
    merge(l,mid,r);
}
int main(){
    scanf("%d",&n);
    for(int i=0;i<n;i++)scanf("%d",&a[i]);
    dic(0,n-1);
    printf("%lld",sum);
}

快速排序：

算法描述

快速排序算法通过多次比较和交换来实现排序，其排序流程如下：

1. 首先设定一个分界值，通过该分界值将数组分成左右两部分。
2. 将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
3. 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
4. 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

代码

void q_sort(int l,int r){
    int i=l,j=r,x=a[l+r>>1];
    while(i<=j){//i>j时结束 
        while(a[i]<x)i++;
        while(a[j]>x)j--;
        if(i<=j)swap(a[i++],a[j--])
    }
    if(l<j)q_sort(l,j);
    if(i<r)q_sort(i,r); 
}

快排典例

第k小数

题目大意：

给你一个长度为n的序列，求序列中第k小数的多少。

求第k大数思路：

给定n个整数，如何求出第k大的数？我们当然可以直接对这n个整数进行快速排序，然后输出从大到小排在第k个的数，时间复杂度为$O(nlogn)$。实际上利用类似于快速排序的思想，只需要$O(n)$的时间即可求出第k大数。

从大到小进行快速排序算法的思想是，在每一层递归中，随机选取一个数为基准，把比它大的数交换到“左半段”，把其余的数和基准值自身一起作为“右半段”，然后继续递归对左右两边分别进行排序，在平均情况下快速排序的复杂度为$O(nlogn)$

实际上在每次选取基准值后，我们可以统计出大于基准值的数的数量cnt，如果k≤cnt，我们就在右半段（比基准值大的数中）寻找第k大数；如果k>cmt，我们般在左半段（小于或等于基准值的数中）寻找第k-cnt大数。因此，寻找第k大数时，我们只需要进入左右两半二者之一继续递归，在平均情况下，复杂度为$n+n/2+n/4+\cdot \dots +1=O(n)$

本题思路：

我们可以统计出小于基准值的数的数量cnt，如果k≤cnt，我们就在左半段（小于或等于基准值的数中）寻找第k小数；如果k>cmt，我们般在右半段（比基准值大的数中）寻找第k-cnt小数。因此，寻找第k小数时，我们只需要进入左右两半二者之一继续递归，在平均情况下，复杂度为$n+n/2+n/4+\cdot \dots +1=O(n)$

ac代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e6+10;
int a[maxn];
template<class T>inline void read(T &x){
    x=0;register char c=getchar();register bool f=0;
    while(!isdigit(c))f^=c=='-',c=getchar();
    while(isdigit(c))x=(x<<3)+(x<<1)+(c^48),c=getchar();
    if(f)x=-x;
}//快读
int q_find(int l,int r,int k){//第k小数 
    int i=l,j=r,x=a[l+r>>1];
    while(i<=j){//i>j时结束 
        while(a[i]<x)i++;
        while(a[j]>x)j--;
        if(i<=j)swap(a[i++],a[j--]);
    }
    if(k<=j)return q_find(l,j,k);//第k小数在左边
    if(k>=i)return q_find(i,r,k);//第k小数在右边
    return a[k];//不写会TLE
    //只有找到第k小数后才执行这个return 
}
int main(){   
    int n,k,t;
    read(t);
    while(t--){
        read(n);read(k);
        for(int i=1;i<=n;++i) read(a[i]);
        printf("%d\n",q_find(1,n,k));
    }   
    return 0;
}

两种排序区别

归并排序速度仅次于快速排序，为稳定排序算法，即相等的元素的顺序不会改变.

如输入记录 1(1) 3(2) 2(3) 2(4) 5(5) (括号中是记录的关键字)时输出的 1(1) 2(3) 2(4) 3(2) 5(5) 中两个2排序后的顺序是按输入的顺序.

这对要排序数据包含多个信息而要按其中的某一个信息排序,要求其它信息尽量按输入的顺序排列时很重要。

归并排序的比较次数小于快速排序的比较次数，移动次数一般多于快速排序的移动次数。