【ACWing】785. 快速排序

题目地址：

https://www.acwing.com/problem/content/description/787/

给定一个长$n$的数列，将其从小到大排序。

输入格式：
输入共两行，第一行包含整数$n$。第二行包含$n$个整数（所有整数均在$1\sim 10^9$范围内），表示整个数列。

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

数据范围：
$1\le n\le 100000$

用快速排序。代码如下（算法正确性可以用数学归纳法证明）：

#include 
using namespace std;

const int N = 100010;
int a[N];

void quick_sort(int l, int r) {
  if (l >= r) return;

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

  quick_sort(l, j), quick_sort(i, r);
}

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

  quick_sort(0, n - 1);
  for (int i = 0; i < n; i++) printf("%d ", a[i]);
}

平均时间复杂度$O(n\log n)$，平均空间$O(\log n)$（这是递归栈深度的期望）。

也可以用基数排序。思路是这样的，我们先将所有数按照个位进行一个稳定排序，排好之后，再按十位进行一个稳定排序，以此类推，直到最高位排好，此时整个数组就排好序了（算法正确性显而易见，如果$x<y$，那么找到最高的不等的那一位，在进行若干轮排序排到那一位的时候，$x$将排到$y$前面，之后不会变动，所以算法正确）。以按个位排序举例，先用一个数组$c[k]$来记录个位数为$k$的数字有多少个，接着求$c$的前缀和数组，这样，$c[k]$就表示个位数小于等于$k$的数有多少个，从而$a$里个位数为$k$的最后的那个数将排到第$c[k]$的位置，而$a$里个位数为$k$的倒数第二的那个数将排到第$c[k]-1$的位置，以此类推，所以我们可以从后往前遍历$a$，将$a[i]$放到$c[a[i]\mathrm{mod}10]$的那个位置，接着让$c[a[i]\mathrm{mod}10]$减$1$。重复若干轮，直到最高位也排好序为止。代码如下：

#include 
#include 
using namespace std;

const int N = 1e5 + 10;
int n, a[N];
int tmp[N], cnt[15];

int max_num() {
  int M = 0;
  for (int i = 1; i <= n; i++) M = max(M, a[i]);
  return M;
}

void radix_sort(int M) {
  // radix = 1时按个位排序，radix = 10时按十位排序，以此类推
  for (int rad = 1; rad <= M; rad *= 10) {
    memset(cnt, 0, sizeof cnt);
  	// 数一下radix位为1,2,...的数有多少个
    for (int i = 1; i <= n; i++) cnt[a[i] / rad % 10]++;
    // 求前缀和
    for (int i = 1; i < 10; i++) cnt[i] += cnt[i - 1];
    // 逆序遍历，将a按radix位做稳定排序的结果存入tmp
    for (int i = n; i; i--) tmp[cnt[a[i] / rad % 10]--] = a[i];
    // 回填
    for (int i = 1; i <= n; i++) a[i] = tmp[i];
  }
}

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

  radix_sort(max_num());
  for (int i = 1; i <= n; i++) printf("%d ", a[i]);
}

时间复杂度$O(nD)$，$D$是数组最大值在十进制下的位数，空间$O(n)$。

也可以用堆排序。代码如下：

#include 
using namespace std;

const int N = 100010;
int a[N];

void sift_down(int i, int n) {
  int x = a[i];
  while (i << 1 <= n) {
    int j = i << 1;
    if (j + 1 <= n && a[j + 1] > a[j]) j++;
    if (a[j] <= x) break;
    a[i] = a[j];
    i = j;
  }

  a[i] = x;
}

void heapify(int n) {
  for (int i = n >> 1; i; i--) sift_down(i, n);
}

void heap_sort(int n) {
  heapify(n);
  for (int i = n; i; i--) {
    swap(a[1], a[i]);
    sift_down(1, i - 1);
  }
}

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

  heap_sort(n);
  for (int i = 1; i <= n; i++) printf("%d ", a[i]);
}

时间复杂度$O(n\log n)$，空间$O(1)$。