排序算法：快排与归并

排序模板

主要记录快速排序与归并排序

快速排序主要是先处理左右两端，再进行递归

归并排序是先递归，在处理左右两端

题目概述：

给定你一个长度为 n 的整数数列。

请你使用快速排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

输入格式

输入共两行，第一行包含整数 n。

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

输出格式

输出共一行，包含 n 个整数，表示排好序的数列。

数据范围

1≤n≤100000,

1≤k≤n.

输入样例：

 5
 3 1 2 4 5

输出样例：

 1 2 3 4 5

快速排序

代码模板：

 #include <bits/stdc++.h>
 ​
 using namespace std;
 ​
 const int N = 1e6+10;
 int n;
 int q[N];
 ​
 // 对于输入输出的优化，关闭兼容，提高输入输出速度
 void init(){
     ios::sync_with_stdio(false);
     cin.tie(0);
     cout.tie(0);
 }
 ​
 void quick_sort(int q[], int l, int r){
     if(l >= r){
         return;
     }
     // 1.选择分界点，确定左右两个指针，l-1与r+1是避免边界问题
     int x = q[l];
     int i = l-1, j = r+1;
     
     // 2.对分界点左右两端使用双指针进行处理，使得i指针左边都为小于x的数，j指针右边都为大于x的数
     // 此部分为重点
     while(i < j){  // 最外层循环，当i<j时循环停止，则左右两端有序
         // 双指针的思想，通过双指针处理数组，使数组部分有序
         do i++ ; while (q[i]<x);
         do j-- ; while (q[j]>x);
         // 若满足此条件则交换两个数,目的还是有序
         if(i < j) swap(q[i], q[j]);
     }
     
     // 3.递归处理左右两端，使用以上方法再次排序
     quick_sort(q, l, j);
     quick_sort(q, j+1, r);
 ​
 }
 ​
 int main(){
     init();
     cin>>n;
     for(int i = 0; i < n; i++) cin>>q[i];
 ​
     quick_sort(q, 0, n-1);
 ​
     for(int i = 0; i < n; i++) printf("%d ", q[i]);
 ​
     return 0;
 }
 ​

归并排序

 

代码模板：

#include <iostream>
 ​
 using namespace std;
 ​
 const int N = 1e6+10;
 int n;
 int q[N], 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];
     }
 ​
 }
 ​
 int main(){
 ​
     scanf("%d", &n);
     for(int i = 0; i<n; i++) cin>>q[i];
 ​
     merge_sort(q, 0 ,n-1);
 ​
     for(int i = 0; i<n; i++) cout<<q[i]<<" ";
 ​
     return 0;
 }

补充例题：

给定一个长度为 n 的整数数列，请你计算数列中的逆序对的数量。

逆序对的定义如下：对于数列的第 i个和第 j 个元素，如果满足 i<j 且 a[i]>a[j]，则其为一个逆序对；否则不是。

输入格式

第一行包含整数 n，表示数列的长度。

第二行包含 n 个整数，表示整个数列。

输出格式

输出一个整数，表示逆序对的个数。

数据范围

1≤n≤100000， 数列中的元素的取值范围 [1,​]。

输入样例：

 6
 2 3 4 5 6 1

输出样例：

 5

题解：

#include <iostream>
 ​
using namespace std;
 ​
 typedef long long LL;
 ​
 const int N = 100010;
 int q[N], temp[N];
 int n;
 ​
 LL merge_sort(int l ,int r){
     if(l>=r) return 0;
     
     int mid = l+r>>1;
     LL res = merge_sort(l,mid)+merge_sort(mid+1,r);
     
     int i = l, j = mid+1, k = 0;
     while(i<=mid&&j<=r){
         if(q[i]<=q[j]) temp[k++] = q[i++];
         else{
             temp[k++] = q[j++];
             res += mid-i+1;
         }
     }
     
     while(i<=mid) temp[k++] = q[i++];
     while(j<=r) temp[k++] = q[j++];
     
     for(int i = l,j = 0; i<=r; i++, j++) q[i] = temp[j];
     return res;
 }
 ​
 int main(){
     
     cin>>n;
     
     for(int i=0; i<n; i++){
         cin>>q[i];
     }
     
     cout<<merge_sort(0, n-1);
     return 0;
 }

补：是否稳定问题

如果一个数在排完序后中的位置发生变化，则不稳定，否则是稳定的。

快排是不稳定的算法，归并是稳定的算法。