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

▶ 书中第二章部分程序，加上自己补充的代码，包括插入排序，选择排序，Shell 排序

● 插入排序

package package01;

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

public class class01
{
    private class01() { }

    public static void sort(Comparable[] a)                     // 插入排序
    {
        int n = a.length;
        for (int i = 0; i < n; i++)
        {
            for (int j = i; j > 0 && less(a[j], a[j - 1]); j--)
            {
                exch(a, j, j - 1);
            }
            //assert isSorted(a, 0, i);                         // 检验是否正确排序
        }
        //assert isSorted(a);
    }

    public static void sort(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);
            }
        }
        //assert isSorted(a, lo, hi);
    }

    public static void sort(Object[] a, Comparator comparator)  // 自定义比较运算的插入排序
    {
        int n = a.length;
        for (int i = 0; i < n; i++)
        {
            for (int j = i; j > 0 && less(a[j], a[j - 1], comparator); j--)
            {
                exch(a, j, j - 1);
            }
            //assert isSorted(a, 0, i, comparator);
        }
        //assert isSorted(a, comparator);
    }

    public static void sort(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);
            }
        }
        //assert isSorted(a, lo, hi, comparator);
    }

    public static void sort2(Comparable[] a)    // 改良版本，不使用逐两元交换，而是位移 - 赋值方法
    {
        int n = a.length;
        boolean exchanges = false;
        for (int i = n - 1; i > 0; i--)   // 倒着扫描一遍，将最小元素放到开头，并统计倒序
        {
            if (less(a[i], a[i - 1]))
            {
                exch(a, i, i - 1);
                exchanges = true;
            }
        }
        if (exchanges == false)         // 如果没有交换，说明已经排好序了
            return;

        for (int i = 2; i < n; i++)     // 正常的排序，从第 3 元素开始
        {
            Comparable v = a[i];
            int j = i;
            for (; less(v, a[j - 1]); j--)
                a[j] = a[j - 1];
            a[j] = v;
        }
        //assert isSorted(a);
    }

    public static void sort3(Comparable[] a)    // 改良版本，使用二分搜索寻找插入位置，减少判断次数
    {
        int n = a.length;
        for (int i = 1; i < n; i++)
        {
            Comparable v = a[i];
            int lo = 0, hi = i;
            for (; lo < hi;)
            {
                int mid = lo + (hi - lo) / 2;
                if (less(v, a[mid]))            // 左边强调整，右边弱调整
                    hi = mid;
                else
                    lo = mid + 1;
            }

            for (int j = i; j > lo; --j)        // 用前面的位移 - 赋值方法
                a[j] = a[j - 1];
            a[lo] = v;
        }
        //assert isSorted(a);
    }

    public static int[] indexSort(Comparable[] a)   // 给定数组 a 及其排序后的数组 a'，对于任意 0 ≤ i ≤ a.length - 1，
    {                                               // a'[i] == a[index[i]]，即 a 排序后第 i 位的值可用 a 和 index 来查找
        int n = a.length;
        int[] index = new int[n];
        for (int i = 0; i < n; i++)
            index[i] = i;

        for (int i = 0; i < n; i++)
            for (int j = i; j > 0 && less(a[index[j]], a[index[j - 1]]); j--)
                exch(index, j, j - 1);
        return index;
    }

    private static boolean less(Comparable v, Comparable w)                 // v < w ?
    {
        return v.compareTo(w) < 0;
    }

    private static boolean less(Object v, Object w, Comparator comparator)  // v < w ?
    {
        return comparator.compare(v, 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 exch(int[] a, int i, int j)     // 间接交换，用于 indexSort
    {
        int swap = a[i];
        a[i] = a[j];
        a[j] = swap;
    }

    // 检验是否完成排序的辅助函数，4 个
    private static boolean isSorted(Comparable[] a)
    {
        return isSorted(a, 0, a.length);
    }

    private static boolean isSorted(Comparable[] a, int lo, int hi)
    {
        for (int i = lo + 1; i < hi; i++)
        {
            if (less(a[i], a[i - 1]))
                return false;
        }
        return true;
    }

    private static boolean isSorted(Object[] a, Comparator comparator)
    {
        return isSorted(a, 0, a.length, comparator);
    }

    private static boolean isSorted(Object[] a, int lo, int hi, Comparator comparator)
    {
        for (int i = lo + 1; i < hi; i++)
        {
            if (less(a[i], a[i - 1], comparator))
                return false;
        }
        return true;
    }

    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.indexSort(a);

        class01.sort(a);

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

● 选择排序，结构类似前面的插入排序，删掉了检查等辅助函数

package package01;

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

public class class01
{
    private class01() {}

    public static void sort(Comparable[] a)
    {
        int n = a.length;
        for (int i = 0; i < n; i++)
        {
            int min = i;
            for (int j = i + 1; j < n; j++)
            {
                if (less(a[j], a[min]))
                    min = j;
            }
            exch(a, i, min);
        }
    }

    public static void sort(Object[] a, Comparator comparator)
    {
        int n = a.length;
        for (int i = 0; i < n; i++)
        {
            int min = i;
            for (int j = i + 1; j < n; j++)
            {
                if (less(a[j], a[min], comparator))
                    min = j;
            }
            exch(a, i, min);
        }
    }

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

    private static boolean less(Object v, Object w, Comparator comparator)
    {
        return comparator.compare(v, 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)
    {
        String[] a = StdIn.readAllStrings();

        class01.sort(a);

        show(a);
    }
}

 ● Shell 排序

package package01;

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

public class class01
{
    private class01() {}

    public static void sort(Comparable[] a)
    {
        int n = a.length, h = 1;
        for (; h < n / 3; h = 3 * h + 1);   // a[n+1] = 3 * a[n] + 1 : 1, 4, 13, 40, 121, 364, 1093, ...
        for (; h >= 1; h /= 3)              // 使用 h 递增序列来逐步排序
        {
            for (int i = h; i < n; i++)
            {
                for (int j = i; j >= h && less(a[j], a[j - h]); j -= h)
                    exch(a, j, j - h);
            }
            //assert isHsorted(a, h);
        }
        //assert isSorted(a);
    }

    private static boolean less(Comparable v, Comparable w)
    {
        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 boolean isHsorted(Comparable[] a, int h) // 检查函数与前面不同，保留
    {
        for (int i = h; i < a.length; i++)
        {
            if (less(a[i], a[i - h]))
                return false;
        }
        return true;
    }

    private static boolean isSorted(Comparable[] a)
    {
        for (int i = 1; i < a.length; i++)
            if (less(a[i], a[i - 1])) return false;
        return true;
    }

    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();

        class01.sort(a);

        show(a);
    }
}