《算法》第二章部分程序 part 3

▶ 书中第二章部分程序，加上自己补充的代码，包括各种优化的快排

package package01;

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;

public class class01
{
    private class01() {}

    public static void sort1(Comparable[] a)    // 基本的快排
    {
        StdRandom.shuffle(a);                   // 数组 a 随机化
        sortKernel1(a, 0, a.length - 1);
    }

    private static void sortKernel1(Comparable[] a, int lo, int hi)  // 快排递归内核
    {
        if (hi <= lo)
            return;
        int j = partition1(a, lo, hi);
        sortKernel1(a, lo, j - 1);              // 用不到 sortKernel1 的返回值
        sortKernel1(a, j + 1, hi);
    }

    private static int partition1(Comparable[] a, int lo, int hi)   // 快排分组
    {
        int i = lo, j = hi + 1;
        for (Comparable v = a[lo];; exch(a, i, j))      // a[lo] 作为分界值，每次循环前要调整 i 和 j，所以初值要过量
        {                                               // 没有 break 退出时调整两个错位的值
            for (i++; i < hi && less(a[i], v); i++);    // 寻找大于 a[lo] 的元素
            for (j--; j > lo && less(v, a[j]); j--);    // 寻找小于 a[lo] 的元素
            if (i >= j)                                 // 指针交叉，说明已经排好了
                break;
        }
        exch(a, lo, j);                                 // 安置哨兵
        return j;                                       // 返回哨兵的位置
    }

    public static Comparable select(Comparable[] a, int k)  // 从数组中选出第 k 小的数字
    {
        StdRandom.shuffle(a);
        int lo = 0, hi = a.length - 1;
        for (; lo < hi;)
        {
            int i = partition1(a, lo, hi);      // 用 a[0] 分段，这是函数 partition 返回安置位置的原因
            if (i > k)                          // 左段过长
                hi = i - 1;
            else if (i < k)                     // 右段过长
                lo = i + 1;
            else
                return a[i];                    // 找到了指定的分位数
        }
        return a[lo];                           // 指针交叉或 k 不合法？
    }

    public static void sort2(Comparable[] a)    // 优化版本，三路快排
    {
        StdRandom.shuffle(a);
        sortKernel2(a, 0, a.length - 1);
    }

    private static void sortKernel2(Comparable[] a, int lo, int hi) // 三路路快排的递归内核，没有 partition 程序
    {
        if (hi <= lo)
            return;
        int pLess = lo, pEqual = lo + 1, pGreater = hi; // 三个指针分别指向小于部分、等于部分、大于部分，且 pEqual 指向当前检查元素
        for (Comparable v = a[lo]; pEqual <= pGreater;)
        {
            int cmp = a[pEqual].compareTo(v);
            if (cmp < 0)
                exch(a, pLess++, pEqual++);             // 当前元素较小，放到左边
            else if (cmp > 0)
                exch(a, pEqual, pGreater--);            // 当前元素较大，放到右边
            else
                pEqual++;                               // 当前元素等于哨兵，仅自增相等部分的指针
        }
        sortKernel2(a, lo, pLess - 1);
        sortKernel2(a, pGreater + 1, hi);
    }

    private static final int INSERTION_SORT_CUTOFF = 8; // 数组规模不大于 8 时使用插入排序

    public static void sort3(Comparable[] a)            // 优化版本，三采样 - 插入排序
    {
        sortKernel3(a, 0, a.length - 1);                // 没有数组随机化
    }

    private static void sortKernel3(Comparable[] a, int lo, int hi) // 递归内核
    {
        if (hi <= lo)
            return;
        if (hi - lo + 1 <= INSERTION_SORT_CUTOFF)                   // 规模较小，使用插入排序
        {
            insertionSort(a, lo, hi + 1);   //Insertion.sort(a, lo, hi + 1);，教材源码使用 edu.princeton.cs.algs4.Insertion
            return;
        }
        int j = partition3(a, lo, hi);
        sortKernel3(a, lo, j - 1);
        sortKernel3(a, j + 1, hi);
    }

    private static int partition3(Comparable[] a, int lo, int hi)   // 分组
    {
        exch(a, median3(a, lo, lo + (hi - lo + 1) / 2, hi), lo);    // 开头、中间和结尾各找 1 元求中位数作为哨兵

        int i = lo, j = hi + 1;
        Comparable v = a[lo];               // 注意相比函数 partition1 少了一层循环

        for (i++; less(a[i], v); i++)
        {
            if (i == hi)                    // 低指针到达右端，所有元素都比哨兵小
            {
                exch(a, lo, hi);            // 哨兵放到最后，返回哨兵位置
                return hi;
            }
        }
        for (j--; less(v, a[j]); j--)
        {
            if (j == lo + 1)                // 高指针到达左端，所有元素都比哨兵大
                return lo;                  // 直接返回原哨兵位置
        }
        for (; i < j;)                      // 在低指针和高指针之间分组
        {
            exch(a, i, j);
            for (i++; less(a[i], v); i++);
            for (j--; less(v, a[j]); j--);
        }
        exch(a, lo, j);
        return j;
    }

    private static final int MEDIAN_OF_3_CUTOFF = 40;   // 数组规模较小时不采用三采样

    public static void sort4(Comparable[] a)            // 优化版本，使用
    {
        sortKernel4(a, 0, a.length - 1);
    }

    private static void sortKernel4(Comparable[] a, int lo, int hi) // 递归内核
    {
        int n = hi - lo + 1;
        if (n <= INSERTION_SORT_CUTOFF)                     // 小规模数组用插入排序
        {
            insertionSort(a, lo, hi + 1);
            return;
        }
        else if (n <= MEDIAN_OF_3_CUTOFF)                   // 中规模数组用三采样
            exch(a, median3(a, lo, lo + n / 2, hi), lo);
        else                                                // 大规模数组使用 Tukey ninther 采样，相当于 9 点采样
        {
            int eps = n / 8, mid = lo + n / 2;
            int ninther = median3(a,
                median3(a, lo, lo + eps, lo + eps + eps),
                median3(a, mid - eps, mid, mid + eps),
                median3(a, hi - eps - eps, hi - eps, hi)
            );
            exch(a, ninther, lo);
        }

        int i = lo, p = lo, j = hi+1, q = hi + 1;         // Bentley-McIlroy 三向分组
        for (Comparable v = a[lo]; ;)
        {
            for (i++; i < hi && less(a[i], v); i++);
            for (j--; j > lo && less(v, a[j]); j--);

            if (i == j && eq(a[i], v))                  // 指针交叉，单独处理相等的情况
                exch(a, ++p, i);
            if (i >= j)
                break;

            exch(a, i, j);
            if (eq(a[i], v))
                exch(a, ++p, i);
            if (eq(a[j], v))
                exch(a, --q, j);
        }
        i = j + 1;
        for (int k = lo; k <= p; k++)
            exch(a, k, j--);
        for (int k = hi; k >= q; k--)
            exch(a, k, i++);
        sortKernel4(a, lo, j);
        sortKernel4(a, i, hi);
    }

    private static void insertionSort(Comparable[] a, int lo, int hi)   // 公用插入排序
    {
        for (int i = lo; i < hi; i++)
        {
            for (int j = i; j > lo && less(a[j], a[j - 1]); j--)
                exch(a, j, j - 1);
        }
    }

    private static int median3(Comparable[] a, int i, int j, int k)     // 计算 3 元素的中位数
    {
        return less(a[i], a[j]) ?
            (less(a[j], a[k]) ? j : less(a[i], a[k]) ? k : i) :
            (less(a[k], a[j]) ? j : less(a[k], a[i]) ? k : i);
    }

    private static boolean less(Comparable v, Comparable w)
    {
        if (v == w)                 // 相同引用时避免内存访问
            return false;
        return v.compareTo(w) < 0;
    }

    private static boolean eq(Comparable v, Comparable w)
    {
        if (v == w)                 // 相同引用时避免内存访问
            return true;
        return v.compareTo(w) == 0;
    }

    private static void exch(Object[] a, int i, int j)
    {
        Object swap = a[i];
        a[i] = a[j];
        a[j] = swap;
    }

    private static void show(Comparable[] a)
    {
        for (int i = 0; i < a.length; i++)
            StdOut.println(a[i]);
    }

    public static void main(String[] args)
    {
        In in = new In(args[0]);
        String[] a = in.readAllStrings();

        class01.sort1(a);
        //class01.sort2(a);
        //class01.sort3(a);
        //class01.sort4(a);
        show(a);
        /*
        for (int i = 0; i < a.length; i++)  // 使用函数 select 进行排序，实际上是逐步挑出 a 中排第 1、第 2、第 3 …… 的元素
        {
            String ith = (String)class01.select(a, i);
            StdOut.println(ith);
        }
        */
    }
}