快速排序与归并排序

快速排序

快排采取的是分而治之的思想。
属于分治算法的一种，分治算法都有三步：

1. 分成子问题
2. 递归处理子问题
3. 子问题合并

快排的几个步骤：
a. 确定分界点：q[l],q[r],q[l+r>>1];三个当中任选一个作为x
b.调整范围：确定一个x（这个x可以是任意的），x左边的所有值是<=x 的，x右边的所有值是>=x的。
c. 递归处理左右两端.quick_sort(
核心是如何调整范围，下边介绍一种双指针的做法，不需要额外开辟空间，时间复杂度为O(N);
维护两个指针i和j,i开始指向最左边0，指向最右边（n-1）;
i指向的数字如果是<=x的，不用操作，让i指针向右移动直到遇到q[i]>x停下来，开始移动j指针，
同理，j指向的数字如果是>=x的，不用操作，让j指针向左边移动直到遇到q[i]<x停下来，此时i指向的数字>x理应放到右边，而j指向的数字<x理应放到左边，所以把i和j指向的数字交换一下swap(q[i],q[j]);
然后继续移动指针i,j向刚才那样，（因为这时i指向的数字又是<=x,j指向的数字又是>=x的了所以可以继续移动），直到指针i,j相遇为止，此时指针左边的所有数字<=x，右边的所有数字>=x;结束这一层的操作，继续递归的处理子问题即可（quick_sort(q,l,j）,quick_sort(q,j+1,r);

Acwing_785. 快速排序
给定你一个长度为 n 的整数数列。
请你使用快速排序对这个数列按照从小到大进行排序。
并将排好序的数列按顺序输出。
输入格式
输入共两行，第一行包含整数 n。
第二行包含 n 个整数（所有整数均在 1∼109 范围内），表示整个数列。
输出格式
输出共一行，包含 n 个整数，表示排好序的数列。
数据范围
1≤n≤100000
输入样例：
5
3 1 2 4 5
输出样例：
1 2 3 4 5
AC代码：

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1e6+10;
int q[N],n;
void quick_sort(int q[],int l,int r){
    if(l>=r) return ;
    int i=l-1, j=r+1, x=q[l+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]);
    }
    quick_sort(q,l,j);
    quick_sort(q,j+1,r);
}
int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d",&q[i]);
    quick_sort(q,0,n-1);
    for(int i=0;i<n;i++) printf("%d ",q[i]);
    return 0;
}

Acwing_786. 第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>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1e6+10;
int q[N],n,k;
void quick_sort(int q[],int l,int r)
{
    if(l>=r) return ;
    int i=l-1,j=r+1,x=q[l+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]);
    }
    quick_sort(q,l,j);
    quick_sort(q,j+1,r);
}
int main(){
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++) scanf("%d",&q[i]);
    quick_sort(q,1,n);
    cout<<q[k]<<endl;
    return 0;
}

归并排序

归并排序同样属于分支思想的一种算法。
不同的是，快排是先处理当前区间，再递归处理子问题；而归并排序则是先递归处理子问题，再进行合并，合并过程中使用的是双指针算法。
归并排序的具体步骤：
1.固定的，取区间的中点作为划分标准(int mid=l+r>>1);
2.分别递归处理左右两个子区间(merge_sort(q,l,mid),merge_sort(q,mid+1,r))
3.合并处理好的子区间(**核心步骤):
采用双指针算法，并且需要开一个额外的数组(tmp)保存合并后的结果：
int i=l,j=mid+1;
while(i<=mid&&j<=r)
if(q[i]<=q[j]) tmp[k++]=q[i++];
else tmp[k++]=q[j++];
4.当一个指针走到尽头的时候，把另一个指针后边的数字也全部放到tmp数组中，
while(i<=mid) tmp[k++]=q[i++];
while(j<=r) tmp[k++]=q[j++];
5.把处理好之后的数组赋给原数组q.
for(i=l,j=r;i<=r;i++,j++) q[i]=tmp[j];

Acwing_787. 归并排序
给定你一个长度为 n 的整数数列。
请你使用归并排序对这个数列按照从小到大进行排序。
并将排好序的数列按顺序输出。
输入格式
输入共两行，第一行包含整数 n。
第二行包含 n 个整数（所有整数均在 1∼109 范围内），表示整个数列。
输出格式
输出共一行，包含 n 个整数，表示排好序的数列。
数据范围
1≤n≤100000
输入样例：
5
3 1 2 4 5
输出样例：
1 2 3 4 5

Ac代码：

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1e6+10;
int q[N],tmp[N],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 i=l,j=mid+1,k=0;
    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];//注意这个赋值语句
}
int main(){
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d",&q[i]);
    merge_sort(q,0,n-1);
    for(int i=0;i<n;i++) printf("%d ",q[i]);
    return 0;
}

下边介绍一道很经典的题目，使用了归并排序与分治的思想。
788. 逆序对的数量
给定一个长度为 n 的整数数列，请你计算数列中的逆序对的数量。
逆序对的定义如下：对于数列的第 i 个和第 j 个元素，如果满足 i<j 且 a[i]>a[j]，则其为一个逆序对；否则不是。
输入格式
第一行包含整数 n，表示数列的长度。
第二行包含 n 个整数，表示整个数列。
输出格式
输出一个整数，表示逆序对的个数。
数据范围
1≤n≤100000，
数列中的元素的取值范围 [1,109]。
输入样例：
6
2 3 4 5 6 1
输出样例：
5

思路分析：
仍然采用分治的思想来进行看待。
像归并排序那样将整个区间分成两份[l,mid],[mid+1,r];
然后逆序对的情况存在三种：1.逆序对在左半边，2.逆序对在有半边，3.逆序对的两个数字一个在左半边，一个在右半边。
对于第三种情况：对于右半边的逆序对来说，左半边的数字的顺序并不影响逆序这种情况下的逆序对的数量。我们可以举例：4 5 2 | 1 3 6,对1来说，如果直接遍历左半边：4>1,5>1,2>1;有三个；如果直接排好序2 4 5 | 1 3 6，对1来说如果2>1,那么2后边的元素也一定都是>1的，所以可以直接加上mid-i+1(i是左半边的指针）,因此可以在归并排序的过程中就将他们的顺序排好。
而 对于第一二种情况，由于归并排序是不断的递归处理子区间的，因此第一二种情况总会在处理子区间的时候被分成两个更小的区间使得两个元素分别在左右两边，然后按照第三种情况进行处理。

Ac代码：

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1e5+10;
typedef long long LL;
int q[N],tmp[N],n;
LL merge(int l,int r)
{
    if(l>=r) return 0;
    int mid=l+r>>1;
    LL res=merge(l,mid)+merge(mid+1,r);//定义res保存答案:等于左右两边的逆序对个数相加
    int i=l,j=mid+1,k=0;
    //走到这步的时候说明上边的递归已经处理完成了，所以此时区间的左右半边分别都是有序的。
    while(i<=mid&&j<=r)
    {
        if(q[i]<=q[j]) tmp[k++]=q[i++];
        else {
        //这种情况就是小的在右边，大的在左边，并且现在指针i的位置的左边一定都比q[j]小，
        //右边一定都比q[j]大。于是使用那个公式更新res
            tmp[k++]=q[j++];
            res+=mid-i+1;
        }
    }
    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(){
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d",&q[i]);
    cout<<merge(0,n-1)<<endl;
    return 0;
}