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

▶ 书中第二章部分程序，加上自己补充的代码，包括若干种归并排序，以及利用归并排序计算数组逆序数

 ● 归并排序

package package01;

import java.util.Comparator;
import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;

public class class01
{
    private class01() {}

    private static void merge(Comparable[] a, Comparable[] aux, int lo, int mid, int hi)    // 归并两个排好序的子数组
    {
        for (int k = lo; k <= hi; k++)
            aux[k] = a[k];

        int i = lo, j = mid + 1;
        for (int k = lo; k <= hi; k++)
        {
            if (i > mid)                    // 后段剩余
                a[k] = aux[j++];
            else if (j > hi)                // 前段剩余
                a[k] = aux[i++];
            else if (less(aux[j], aux[i]))  // 比较
                a[k] = aux[j++];
            else
                a[k] = aux[i++];
        }
    }

    private static void sortTDKernel(Comparable[] a, Comparable[] aux, int lo, int hi)      // 排序递归内核
    {
        if (hi <= lo)
            return;
        int mid = lo + (hi - lo) / 2;
        sortTDKernel(a, aux, lo, mid);
        sortTDKernel(a, aux, mid + 1, hi);
        merge(a, aux, lo, mid, hi);
    }

    public static void sortTD(Comparable[] a)                                               // 自顶向下的归并排序
    {
        Comparable[] aux = new Comparable[a.length];    // 统一分配临时内存
        sortTDKernel(a, aux, 0, a.length - 1);
    }

    private static void indexMerge(Comparable[] a, int[] index, int[] aux, int lo, int mid, int hi)  // 间接排序的归并
    {
        for (int k = lo; k <= hi; k++)
            aux[k] = index[k];

        int i = lo, j = mid + 1;
        for (int k = lo; k <= hi; k++)
        {
            if (i > mid)
                index[k] = aux[j++];
            else if (j > hi)
                index[k] = aux[i++];
            else if (less(a[aux[j]], a[aux[i]]))
                index[k] = aux[j++];
            else
                index[k] = aux[i++];
        }
    }

    private static void indexSortTDKernel(Comparable[] a, int[] index, int[] aux, int lo, int hi)   // 间接排序递归内核
    {
        if (hi <= lo)
            return;
        int mid = lo + (hi - lo) / 2;
        indexSortTDKernel(a, index, aux, lo, mid);
        indexSortTDKernel(a, index, aux, mid + 1, hi);
        indexMerge(a, index, aux, lo, mid, hi);
    }

    public static int[] indexSortTD(Comparable[] a)                                                 // 自顶向下的间接归并排序
    {
        int n = a.length;
        int[] aux = new int[n];
        int[] index = new int[n];
        for (int i = 0; i < n; i++)
            index[i] = i;

        indexSortTDKernel(a, index, aux, 0, n - 1);
        return index;
    }

    public static void sortBU(Comparable[] a)                   // 自底向上的归并排序，不需要递归，合并子数组的函数与前面相同
    {
        int n = a.length;
        Comparable[] aux = new Comparable[n];
        for (int len = 1; len < n; len *= 2)
        {
            for (int lo = 0; lo < n - len; lo += len + len)
            {
                int mid = lo + len - 1;
                int hi = Math.min(lo + len + len - 1, n - 1);
                merge(a, aux, lo, mid, hi);
            }
        }
    }

    // 改良版本
    private static final int CUTOFF = 7;    // 小于该尺寸的数组使用插入排序

    private static void merge2(Comparable[] src, Comparable[] dst, int lo, int mid, int hi) // 区分原数组和目标数组，减少拷贝
    {
        int i = lo, j = mid + 1;
        for (int k = lo; k <= hi; k++)
        {
            if (i > mid)
                dst[k] = src[j++];
            else if (j > hi)
                dst[k] = src[i++];
            else if (less(src[j], src[i]))
                dst[k] = src[j++];
            else
                dst[k] = src[i++];
        }
    }

    private static void sort2TDKernel(Comparable[] src, Comparable[] dst, int lo, int hi)   
    {
        if (hi <= lo + CUTOFF)                                  // 数据较少时使用插入排序
        {
            insertionSort(dst, lo, hi);
            return;
        }
        int mid = lo + (hi - lo) / 2;
        sort2TDKernel(dst, src, lo, mid);
        sort2TDKernel(dst, src, mid + 1, hi);

        if (!less(src[mid + 1], src[mid]))                      // src[mid+1] >= src[mid]，不用归并了
            System.arraycopy(src, lo, dst, lo, hi - lo + 1);    // 数组拷贝，快于 for (int i = lo; i <= hi; i++) dst[i] = src[i];
        else
            merge2(src, dst, lo, mid, hi);
    }

    public static void sort2TD(Comparable[] a)
    {
        Comparable[] aux = a.clone();
        sort2TDKernel(aux, a, 0, a.length - 1);
    }

    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 void exch(Comparable[] a, int i, int j)      // 插入排序用到的交换
    {
        Comparable swap = a[i];
        a[i] = a[j];
        a[j] = swap;
    }

    private static void merge2(Object[] src, Object[] dst, int lo, int mid, int hi, Comparator comparator)  // 自定义类型的版本（同上 5 个函数）
    {
        int i = lo, j = mid + 1;
        for (int k = lo; k <= hi; k++)
        {
            if (i > mid)
                dst[k] = src[j++];
            else if (j > hi)
                dst[k] = src[i++];
            else if (less(src[j], src[i], comparator))
                dst[k] = src[j++];
            else
                dst[k] = src[i++];
        }
    }

    private static void sort2TDKernel(Object[] src, Object[] dst, int lo, int hi, Comparator comparator)
    {
        if (hi <= lo + CUTOFF)
        {
            insertionSort(dst, lo, hi, comparator);
            return;
        }

        int mid = lo + (hi - lo) / 2;
        sort2TDKernel(dst, src, lo, mid, comparator);
        sort2TDKernel(dst, src, mid + 1, hi, comparator);

        if (!less(src[mid + 1], src[mid], comparator))
            System.arraycopy(src, lo, dst, lo, hi - lo + 1);
        else
            merge2(src, dst, lo, mid, hi, comparator);
    }

    public static void sort2TD(Object[] a, Comparator comparator)
    {
        Object[] aux = a.clone();
        sort2TDKernel(aux, a, 0, a.length - 1, comparator);
    }

    private static void insertionSort(Object[] a, int lo, int hi, Comparator comparator)
    {
        for (int i = lo; i <= hi; i++)
        {
            for (int j = i; j > lo && less(a[j], a[j - 1], comparator); j--)
                exch(a, j, j - 1);
        }
    }

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

    private static boolean less(Comparable a, Comparable b)                 // 各排序都用到的比较函数
    {
        return a.compareTo(b) < 0;
    }

    private static boolean less(Object a, Object b, Comparator comparator)  // 自定义类型的比较函数
    {
        return comparator.compare(a, b) < 0;
    }

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

    public static void main(String[] args)
    {
        String[] a = StdIn.readAllStrings();
        //int[] index = class01.indexSortTD(a);

        class01.sortTD(a);
        //class01.sortBU(a);
        //class01.sort2TD(a);
        //for (int i = 0; i<a.length; i++)
        //    StdOut.println(index[i]);
        System.out.printf("
Finish!
");
    }
}

● 利用归并排序来计算数组的逆序数，只注释了与归并排序不一样的地方

package package01;

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

public class class01
{
    private class01() {}

    private static long merge(int[] a, int[] aux, int lo, int mid, int hi)  // 限定输入为 int 数组
    {
        long inversions = 0;

        for (int k = lo; k <= hi; k++)
            aux[k] = a[k];

        int i = lo, j = mid + 1;
        for (int k = lo; k <= hi; k++)
        {
            if (i > mid)
                a[k] = aux[j++];
            else if (j > hi)
                a[k] = aux[i++];
            else if (aux[j] < aux[i])                // 算术比较
            {
                a[k] = aux[j++];
                inversions += (mid - i + 1);        // 多了一步计算
            }
            else
                a[k] = aux[i++];
        }
        return inversions;                            // 返回逆序数
    }

    private static long count(int[] a, int[] b, int[] aux, int lo, int hi)  // 部分计数函数
    {
        long inversions = 0;
        if (hi <= lo)
            return 0;
        int mid = lo + (hi - lo) / 2;
        inversions += count(a, b, aux, lo, mid);        // 分治和归并的部分补上计算
        inversions += count(a, b, aux, mid + 1, hi);
        inversions += merge(b, aux, lo, mid, hi);
        return inversions;
    }

    public static long count(int[] a)                   // 可调用的计数函数
    {
        int[] b = new int[a.length];
        int[] aux = new int[a.length];
        for (int i = 0; i < a.length; i++)
            b[i] = a[i];
        return count(a, b, aux, 0, a.length - 1);
    }

    private static long brute(int[] a, int lo, int hi)  // 枚举方法计算逆序数
    {
        long inversions = 0;
        for (int i = lo; i <= hi; i++)
        {
            for (int j = i + 1; j <= hi; j++)
                if (a[j] < a[i])
                    inversions++;
        }
        return inversions;
    }

    // 自定义类型版本
    private static <Key extends Comparable<Key>> long merge(Key[] a, Key[] aux, int lo, int mid, int hi)
    {
        long inversions = 0;

        for (int k = lo; k <= hi; k++)
            aux[k] = a[k];

        int i = lo, j = mid + 1;
        for (int k = lo; k <= hi; k++)
        {
            if (i > mid)
                a[k] = aux[j++];
            else if (j > hi)
                a[k] = aux[i++];
            else if (less(aux[j], aux[i]))            // 比较方法改回去了
            {
                a[k] = aux[j++];
                inversions += (mid - i + 1);
            }
            else
                a[k] = aux[i++];
        }
        return inversions;
    }

    private static <Key extends Comparable<Key>> boolean less(Key v, Key w)
    {
        return (v.compareTo(w) < 0);
    }

    private static <Key extends Comparable<Key>> long count(Key[] a, Key[] b, Key[] aux, int lo, int hi)
    {
        long inversions = 0;
        if (hi <= lo)
            return 0;
        int mid = lo + (hi - lo) / 2;
        inversions += count(a, b, aux, lo, mid);
        inversions += count(a, b, aux, mid + 1, hi);
        inversions += merge(b, aux, lo, mid, hi);
        return inversions;
    }

    public static <Key extends Comparable<Key>> long count(Key[] a)
    {
        Key[] b = a.clone();
        Key[] aux = a.clone();
        return count(a, b, aux, 0, a.length - 1);        
    }

    private static <Key extends Comparable<Key>> long brute(Key[] a, int lo, int hi)
    {
        long inversions = 0;
        for (int i = lo; i <= hi; i++)
        {
            for (int j = i + 1; j <= hi; j++)
                if (less(a[j], a[i]))
                    inversions++;
        }
        return inversions;
    }

    public static void main(String[] args)  // 使用文件名而不是重定向来作为输入
    {
        In in = new In(args[0]);
        int[] a = in.readAllInts();
        int n = a.length;
        int[] b = new int[n];
        for (int i = 0; i<n; i++)
            b[i] = a[i];

        StdOut.println(class01.count(a));
        StdOut.println(class01.count(b));
    }
}