《算法》第五章部分程序 part 2

▶ 书中第五章部分程序，包括在加上自己补充的代码，字符串高位优先排序（计数 + 插排），（原地排序），（三路快排，与前面的三路归并排序相同）

● 计数 + 插排

package package01;

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;

public class class01
{
    private static final int BITS_PER_BYTE = 8;
    private static final int BITS_PER_INT = 32;
    private static final int R = 256;
    private static final int CUTOFF = 15;   // 尺寸不超过 CUTOFF 的数组使用插入排序

    private class01() {}

    public static void sort(String[] a)     // 对字符串的排序
    {
        int n = a.length;
        String[] aux = new String[n];
        sortKernel(a, 0, n - 1, 0, aux);
    }

    private static void sortKernel(String[] a, int lo, int hi, int d, String[] aux)
    {
        if (hi <= lo + CUTOFF)              // 数组较小，使用插入排序
        {
            insertion(a, lo, hi, d);
            return;
        }
        int[] count = new int[R + 2];
        for (int i = lo; i <= hi; i++)
            count[charAt(a[i], d) + 2]++;
        for (int r = 0; r < R + 1; r++)
            count[r + 1] += count[r];
        for (int i = lo; i <= hi; i++)
            aux[count[charAt(a[i], d) + 1]++] = a[i];
        for (int i = lo; i <= hi; i++)      // 写回时注意偏移
            a[i] = aux[i - lo];
        for (int r = 0; r < R; r++)         // 每个字母开头的子数组分别排序
            sortKernel(a, lo + count[r], lo + count[r + 1] - 1, d + 1, aux);
    }

    private static void insertion(String[] a, int lo, int hi, int d)    // 数组 a 关于第 d 位插入排序
    {
        for (int i = lo; i <= hi; i++)
        {
            for (int j = i; j > lo && less(a[j], a[j - 1], d); j--)
                exch(a, j, j - 1);
        }
    }

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

    private static int charAt(String s, int d)              // 按索引取字符串的字符
    {
        assert d >= 0 && d <= s.length();
        if (d == s.length())
            return -1;
        return s.charAt(d);
    }

    private static boolean less(String v, String w, int d)
    {
        //assert v.substring(0, d).equals(w.substring(0, d)); // 先检查等于
        for (int i = d; i < Math.min(v.length(), w.length()); i++)
        {
            if (v.charAt(i) < w.charAt(i))
                return true;
            if (v.charAt(i) > w.charAt(i))
                return false;
        }
        return v.length() < w.length();
    }

    public static void sort(int[] a)        // 对数组的排序
    {
        int n = a.length;
        int[] aux = new int[n];
        sortKernel(a, 0, n - 1, 0, aux);
    }

    private static void sortKernel(int[] a, int lo, int hi, int d, int[] aux)
    {
        if (hi <= lo + CUTOFF)
        {
            insertion(a, lo, hi, d);
            return;
        }
        int[] count = new int[R + 1];
        int mask = R - 1;
        int shift = BITS_PER_INT - BITS_PER_BYTE * d - BITS_PER_BYTE;
        for (int i = lo; i <= hi; i++)
        {
            int c = (a[i] >> shift) & mask;
            count[c + 1]++;
        }
        for (int r = 0; r < R; r++)
            count[r + 1] += count[r];
        if (d == 0)                         // 符号位，0x00-0x7F 要排在 0x80-0xFF 的后面
        {
            int shift1 = count[R] - count[R / 2];
            int shift2 = count[R / 2];
            for (int r = 0; r < R / 2; r++)
                count[r] += shift1;
            for (int r = R / 2; r < R; r++)
                count[r] -= shift2;
        }
        for (int i = lo; i <= hi; i++)
        {
            int c = (a[i] >> shift) & mask;
            aux[count[c]++] = a[i];
        }
        for (int i = lo; i <= hi; i++)
            a[i] = aux[i - lo];
        if (d == 4)                         // 已经到了最高位，不用分治了
            return;
        if (count[0] > 0)
            sortKernel(a, lo, lo + count[0] - 1, d + 1, aux);
        for (int r = 0; r < R; r++)
        {
            if (count[r + 1] > count[r])    // 存在数字第 d 位是 r 的数字需要排序
                sortKernel(a, lo + count[r], lo + count[r + 1] - 1, d + 1, aux);
        }
    }

    private static void insertion(int[] a, int lo, int hi, int d)
    {
        for (int i = lo; i <= hi; i++)
        {
            for (int j = i; j > lo && a[j] < a[j - 1]; j--)
                exch(a, j, j - 1);
        }
    }

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

    public static void main(String[] args)
    {
        String[] a = StdIn.readAllStrings();
        int n = a.length;
        sort(a);
        for (int i = 0; i < n; i++)
            StdOut.println(a[i]);
    }
}

● 原地排序

package package01;

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;

public class class01
{
    private static final int R = 256;
    private static final int CUTOFF = 0;

    private class01() {}

    public static void sort(String[] a)
    {
        int n = a.length;
        sortKernel(a, 0, n - 1, 0);
    }

    private static void sortKernel(String[] a, int lo, int hi, int d)
    {
        if (hi <= lo + CUTOFF)
        {
            insertion(a, lo, hi, d);
            return;
        }
        int[] heads = new int[R + 2];       // 需要记录每个字符出现的首位和末位
        int[] tails = new int[R + 1];
        for (int i = lo; i <= hi; i++)
            heads[charAt(a[i], d) + 2]++;
        heads[0] = lo;                      // heads 首位设为 lo，方便直接做 a 的索引
        for (int r = 0; r < R + 1; r++)
        {
            heads[r + 1] += heads[r];
            tails[r] = heads[r + 1];        // tails 等于前缀和的 heads 左移一格，等于下一个字符出现的位置
        }
        for (int r = 0; r < R + 1; r++)     // 循环完成所有字符
        {
            for (; heads[r] < tails[r]; heads[r]++)     // 循环直到所有 heads 向 tails 靠拢
            {
                // a[heads[r]] 作为临时位置，每次把其上字符串发送到排序后正确的位置上，替换下来的字符串放回，用于下一次发送
                for (int c = charAt(a[heads[r]], d); c + 1 != r; c = charAt(a[heads[r]], d))
                    exch(a, heads[r], heads[c + 1]++);  // 每次发送后要后移同一字符串的目标位置
            }
        }
        for (int r = 0; r < R; r++)                     // 分治所有子数组
            sortKernel(a, tails[r], tails[r + 1] - 1, d + 1);
    }

    private static void insertion(String[] a, int lo, int hi, int d)
    {
        for (int i = lo; i <= hi; i++)
        {
            for (int j = i; j > lo && less(a[j], a[j - 1], d); j--)
                exch(a, j, j - 1);
        }
    }

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

    private static int charAt(String s, int d)
    {
        assert d >= 0 && d <= s.length();
        if (d == s.length())
            return -1;
        return s.charAt(d);
    }

    private static boolean less(String v, String w, int d)
    {
        // assert v.substring(0, d).equals(w.substring(0, d));
        for (int i = d; i < Math.min(v.length(), w.length()); i++)
        {
            if (v.charAt(i) < w.charAt(i))
                return true;
            if (v.charAt(i) > w.charAt(i))
                return false;
        }
        return v.length() < w.length();
    }

    public static void main(String[] args)
    {
        String[] a = StdIn.readAllStrings();
        int n = a.length;
        sort(a);
        for (int i = 0; i < n; i++)
            StdOut.println(a[i]);
    }
}

● 三路快排

package package01;

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

public class class01
{
    private static final int CUTOFF = 15;

    private class01() {}

    public static void sort(String[] a)
    {
        StdRandom.shuffle(a);
        sortKernel(a, 0, a.length - 1, 0);
    }

    private static void sortKernel(String[] a, int lo, int hi, int d)
    {
        if (hi <= lo + CUTOFF)
        {
            insertion(a, lo, hi, d);
            return;
        }
        int lt = lo, gt = hi;
        int v = charAt(a[lo], d);
        for (int i = lo + 1; i <= gt;)
        {
            int t = charAt(a[i], d);
            if (t < v)
                exch(a, lt++, i++);
            else if (t > v)
                exch(a, i, gt--);
            else
                i++;
        }
        sortKernel(a, lo, lt - 1, d);
        if (v >= 0)
            sortKernel(a, lt, gt, d + 1);
        sortKernel(a, gt + 1, hi, d);
    }

    private static void insertion(String[] a, int lo, int hi, int d)
    {
        for (int i = lo; i <= hi; i++)
        {
            for (int j = i; j > lo && less(a[j], a[j - 1], d); j--)
                exch(a, j, j - 1);
        }
    }

    private static boolean less(String v, String w, int d)
    {
        assert v.substring(0, d).equals(w.substring(0, d));
        for (int i = d; i < Math.min(v.length(), w.length()); i++)
        {
            if (v.charAt(i) < w.charAt(i))
                return true;
            if (v.charAt(i) > w.charAt(i))
                return false;
        }
        return v.length() < w.length();
    }

    private static int charAt(String s, int d)
    {
        assert d >= 0 && d <= s.length();
        if (d == s.length())
            return -1;
        return s.charAt(d);
    }

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

    public static void main(String[] args)
    {
        String[] a = StdIn.readAllStrings();
        int n = a.length;

        sort(a);

        for (int i = 0; i < n; i++)
            StdOut.println(a[i]);
    }
}