常用的排序算法實現(1)-選擇排序、插入排序、希爾排序、歸併排序、快速排序

package sort;

import java.util.Arrays;

/**
 * 描述:
 * 排序算法
 *
 * @author wanghui email:[email protected]
 * @create 2020-04-13 上午11:03
 */
public class SortAlgorithm {

    private static Comparable[] aux;

    public static void main(String[] args) {
        String[] a = {"M", "E", "R", "G", "E", "S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
        System.out.println(Arrays.toString(a));
        quick3Sort(a);
        System.out.println(Arrays.toString(a));
    }

    /**
     * 選擇排序, 比較次數~n*n/2,交換次數~n。
     *
     * @param a
     */
    public static void selectSort(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);
            }
        }
    }

    /**
     * 插入排序,對部分有序數組十分高效，同時很適合小估摸數組。
     * 比較和交換次數：
     * 平均情況下：~n*n/4, ~n*n/4
     * 最壞情況下：~n*n/2， ~n*n/2
     * 最好情況下：~n-1,0
     *
     * @param a
     */
    public static void insertionSort(Comparable[] a) {
        int n = a.length;
        for (int i = 1; i < n; i++) {
            for (int j = i; j > 0 && less(a[j], a[j - 1]); j--) {
                exch(a, j, j - 1);
            }
        }
    }

    /**
     * 希爾排序，通過插入排序實現；可用於大型數組。與選擇和插入排序相比較，數組越大，優勢越明顯
     * 比較次數：最壞情況下~n^(3/2)
     *
     * @param a
     */
    public static void shellSort(Comparable[] a) {
        int n = a.length;
        int h = 1;
        //h的最有選擇較複雜，這裏的實現使用了序列1/2(3^k-1),從n/3開始遞減至1
        while (h < n / 3) {
            h = 3 * h + 1;
        }
        while (h >= 1) {
            for (int i = 0; i < n; i++) {
                for (int j = i; j > h && less(a[j], a[j - h]); j -= h) {
                    exch(a, j, j - h);
                }
            }
            h = h / 3;
        }
    }

    /**
     * 歸併排序
     *
     * @param a
     */
    public static void mergeSort1(Comparable[] a) {
        aux = new Comparable[a.length];
        mergeSort1(a, 0, a.length - 1);
    }

    /**
     * 自頂向下歸併排序
     * 時間：~nlgn
     *
     * @param a
     * @param lo
     * @param hi
     */
    private static void mergeSort1(Comparable[] a, int lo, int hi) {

        if (hi <= lo) {
            return;
        }
        int mid = lo + (hi - lo) / 2;
        mergeSort1(a, lo, mid);
        mergeSort1(a, mid + 1, hi);
        mergeArray(a, lo, mid, hi);
    }


    /**
     * 自底向上的歸併排序
     *
     * @param a
     */
    private static void mergeSort2(Comparable[] a) {
        int n = a.length;
        aux = new Comparable[n];

        /*
        第一層循環：每次內循環歸併的數組大小
        第二層循環：循環歸併每一個分隔的子數組
         */
        for (int sz = 1; sz < n; sz = sz + sz) {
            for (int lo = 0; lo < n - sz; lo += sz + sz) {
                mergeArray(a, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, n - 1));
            }
        }
    }

    /**
     * 原地歸併
     *
     * @param a
     * @param lo
     * @param mid
     * @param hi
     */
    private static void mergeArray(Comparable[] a, int lo, int mid, int hi) {
        int i = lo;
        int j = mid + 1;
        Comparable[] aux = new Comparable[a.length];
        for (int k = 0; k < a.length; k++) {
            aux[k] = a[k];
        }
        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++];
            }

        }

    }

    /**
     * 快速排序
     *
     * @param a
     */
    public static void quickSort(Comparable[] a) {
        quickSort(a, 0, a.length - 1);
    }

    private static void quickSort(Comparable[] a, int lo, int hi) {

        if (hi <= lo) {
            return;
        }
        int j = quickPartition(a, lo, hi);
        quickSort(a, lo, j - 1);
        quickSort(a, j + 1, hi);
    }

    /**
     * 切分操作
     * 快速排序的關鍵函數，切分後，切分點前後數組應該滿足一下條件：
     * lo,j-1中所有元素均不大於索引位置爲j的元素
     * j+1,hi中所有元素均不小於索引位置爲j的元素
     *
     * @param a
     * @param lo
     * @param hi
     * @return
     */
    private static int quickPartition(Comparable[] a, int lo, int hi) {
        int i = lo, j = hi + 1;
        Comparable v = a[lo];
        while (true) {
            while (less(a[++i], v)) {
                if (i == hi) {
                    break;
                }
            }
            while (less(v, a[--j])) {
                if (j == lo) {
                    break;
                }
            }
            if (i >= j) {
                break;
            }
            exch(a, i, j);
        }
        exch(a, lo, j);

        return j;
    }

    /**
     * 三項切分的快速排序
     */
    public static void quick3Sort(Comparable[] a) {
        quick3Sort(a, 0, a.length-1);
    }


    /**
     * 三項切分的快速排序實現
     * 數組分爲四段區域：
     * 第一段-->[lo-lt] 小於 a[lo]
     * 第二段-->[lt-i]  等於 a[lo]
     * 第三段-->[i-gt]  不確定區域
     * 第四段-->[gt-hi] 大於a[lo]
     * @param a
     * @param lo
     * @param hi
     */
    private static void quick3Sort(Comparable[] a, int lo, int hi) {
        if (hi < lo) {
            return;
        }
        int lt = lo, i = lo + 1, gt = hi;
        Comparable v = a[lo];
        while (i <= gt) {
            int cmp = a[i].compareTo(v);
            if (cmp < 0) {
                exch(a, lt++, i++);
            } else if (cmp > 0) {
                exch(a, i, gt--);
            } else {
                i++;
            }
        }
        quick3Sort(a, lo, lt - 1);
        quick3Sort(a, gt + 1, hi);
    }


    /**
     * 判斷是否有序
     *
     * @param a
     * @return
     */
    public static boolean isSorted(Comparable[] a) {
        for (int i = 1; i < a.length; i++) {
            if (less(a[i], a[i - 1])) {
                return false;
            }
        }
        return true;
    }

    /**
     * 數組輸出
     *
     * @param a
     */
    private static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }

    /**
     * 降序比較大小寫；當v<w時返回true，反之返回false。
     *
     * @param v
     * @param w
     * @return
     */
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    /**
     * 數據位置交換。
     *
     * @param a
     * @param i
     * @param j
     */
    private static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;

    }

}