算法导论-第8章-线性时间排序

前言

此前我们已经学习了几种$\Omicron(n \log n)$的排序算法，这些排序算法都有一个有趣性质，在排序的最终结果中，各元素的次序依赖于它们之间的比较，我们将这类排序称为比较排序(comparison sort)。

8.1节将要证明对包含$n$个元素的输入序列，在最坏情况下，任何比较排序都要经过$\Omega(n \log n)$次比较。

8.2节、8.3节、8.4节将要介绍三种线性时间复杂度适用于某些特定输入的的排序：计数排序(counting sort)、基数排序(radix sort)、和桶排序(bucket sort)。这些排序通过其它方法来确定排序顺序。

8.1 排序算法的下界

决策树模型

在决策树中，每个内部结点都以$i:j$标记，其中$i$和$j$满足$1 \le i,j \le n$，$n$是输入序列中的元素个数。每个叶结点上都标注一个序列$<\pi(1),\pi(2),\cdots,\pi(n),>$。排序算法的执行对应于一条从数的根结点到叶结点的路径。每个内部结点表示一次比较$a_i \le a_j$。左子树表示确定$a_i \le a_j$之后的后续比较，右子树表示确定$a_i \gt a_j$的后续比较。当到达叶结点后，表示排序以完成。

例如，对于3个元素的插入排序决策树，输入序列$<a_1=6,a_2=8,a_3=5>$，叶结点$<3,1,2>$表示排序的结果是$a_3=5 \le a_1=6 \le a_2=8$。对于输入元素来说，共有$3!=6$种可能的排列，因此决策树包含6个叶结点。

定理：在最坏情况下，任何比较排序算法都需要做$\Omega(n \log n)$次比较。

证明：设决策树高度为$h$，具有$l$个叶结点，则$n! \le l \le 2^h$，两边取对数，得$h \ge \log(n!)=\Omega(n \log n)$。

推论：堆排序和归并排序都是渐近最优的比较排序算法。

8.2 计数排序

计数排序假设$n$个输入元素中的每一个都是在$0$到$k$区间内的一个整数，其中$k$为某个整数。当$k=\Omicron(n)$时，运行时间为$\Theta(n)$。

计数排序的基本思想是：对每一个输入元素$x$，确定小于$x$的元素个数。这样就可以直接把$x$放到输出数组中的位置上。例如，有17个元素小于$x$，则$x$就应该放在第18个输出位置上。当有几个元素相同时，需要略作修改即可。

在计数排序算法的代码中，假设输入是一个数组$A[1..n]$，$A.length=n$。我们还需要另外两个数组：$B[1..n]$存放排序的输出，$C[0..k]$提供临时存储空间，$C[i]$记录小于等于$i$的元素个数。

下图展示了计数排序算法的运行过程。第2-3行for循环的初始化操作之后，数组$C$的值全被置为0；第4-5行for循环遍历输入元素。如果输入元素的值为$i$，就将$C[i]$值加1。于是，在第5行执行完后，$C[i]$中保存的就是等于$i$的元素的个数；第7-8行通过累加计算确定对于每个$i=0,1,2,\cdots,k$，有多少输入元素是小于或等于$i$的，操作过后，$C[i]$记录的即是小于等于$i$的元素个数。

import java.util.Arrays;
 
public class CountingSort {
    public static int[] countingSort(int[] A) {
        if (A == null || A.length == 0) {
            return A;
        }
 
        // 遍历一次输入数组，找到数组中最大和最小元素
        int max = A[0], min = A[0];
        for (int i = 1; i < A.length; i++) {
            if (A[i] > max) {
                max = A[i];
            }
            if (A[i] < min) {
                min = A[i];
            }
        }
 
        int[] C = new int[max - min + 1]; // 辅助数组C，C[i]记录小于等于i的元素个数
 
        for (int j = 0; j < A.length; j++) {
            C[A[j] - min]++; // C[i]存储的是等于A[j]-min=i的元素个数
        }
 
        for (int i = 1; i < C.length; i++) {
            C[i] += C[i - 1]; // C[i]存储的是小于等于i的元素个数
        }
 
        int[] B = new int[A.length]; // 输出数组
 
        for (int j = A.length - 1; j >= 0; j--) {
            B[C[A[j] - min] - 1] = A[j];
            C[A[j] - min]--;
        }
        return B;
    }
 
    public static void main(String[] args) {
        int[] A = {2, 5, 3, 0, 2, 3, 0, 3};
        int[] countingSorted = countingSort(A);
        System.out.println(Arrays.toString(countingSorted));
    }
}

8.3 基数排序

基数排序（radix sort）是一种用在卡片排序机🧐（并不了解这个是什么东西）上的算法。基数排序是先按照最低有效位进行排序的，为了保证基数排序的正确性，一位数排序算法必须是稳定的。

假设$n$个$d$位的元素存放在数组$A$中，其中第1位是最低位，第$d$位是最高位。

基数排序的Java代码实现如下：

import java.util.Arrays;
 
public class RadixSort {
    public static int[] radixSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        // 找到数组中的最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        // 根据最大元素的位数确定排序的轮数
        int digit = 1;
        while (max / 10 > 0) {
            digit++;
            max /= 10;
        }
        int exp = 1;
        int[] temp = new int[arr.length];
        int[] bucket = new int[10];
        for (int i = 0; i < digit; i++) {
            System.arraycopy(arr, 0, temp, 0, arr.length);
            Arrays.fill(bucket, 0);
            // 计数排序
            for (int j = 0; j < temp.length; j++) {
                int radix = (temp[j] / exp) % 10;
                bucket[radix]++;
            }
            for (int j = 1; j < bucket.length; j++) {
                bucket[j] += bucket[j - 1];
            }
            for (int j = temp.length - 1; j >= 0; j--) {
                int radix = (temp[j] / exp) % 10;
                arr[--bucket[radix]] = temp[j];
            }
            exp *= 10;
        }
        return arr;
    }
 
    public static void main(String[] args) {
        int[] A = {329, 457, 657, 839, 436, 720, 355};
        System.out.println(Arrays.toString(radixSort(A)));
    }
}

引理：给定$n$个$d$位数，其中每一个数位有$k$个可能的取值。如果RADIX-SORT使用的稳定排序方法耗时$\Theta(n+k)$，那么它就可以在$\Theta(d(n+k))$时间内完成排序。

8.4 桶排序

桶排序（bucket sort）假设输入数据服从均匀分布，平均情况下它的时间代价为$\Omicron(n)$。与计数排序类似，因为对输入数据作了某种假设，桶排序的速度也很快。具体来说，计数排序假设输入数据都属于一个小区间内的整数，而桶排序则假设元素均匀、独立地分布在$[0, 1)$区间内。

桶排序将$[0, 1)$区间均匀划分为$n$个相同大小的子区间，称为桶。然后，将$n$个输入数分别放到各个桶中。因为输入数据是均匀、独立地分布在$[0, 1)$区间上，所以一般不会出现很多数落在同一个桶中的情况。

核心思想：先对每个桶中的数进行排序，然后遍历每个桶，按照次序把各个桶中的元素列出来即可。

在桶排序的代码中，假设输入是一个包含$n$个元素的数组$A$，且满足$0 \le A[i] \lt 1$。此外，算法还需要一个临时数组$B[0..n-1]$来存放链表（即桶）。