Java-时间复杂度为O(nlogn)的排序算法(快速排序, 归并排序, 堆排序, 希尔排序)

/** 包含多种静态排序方法
 * Created by Andre on 2016/6/27.
 */
public class Sorter {
    /**
     * 快速排序
     * 递归形式
     * 第一个记录为枢轴
     * 不稳定
     * @param a 需要排序的数组
     * @param low  数组的起始下标
     * @param high 数组的结束下标
     */
    public static void QuickSort(int a[], int low, int high) {
        if(low >= high) return;

        int pivot = a[low], l = low, h = high;

        for(; l < h; ) {
            for(; l < h && a[h] >= pivot; h--);
            a[l] =  a[h];
            for(; l < h && a[l] <= pivot; l++);
            a[h] = a[l];
        }
        a[l] = pivot;

        QuickSort(a, low, l - 1);
        QuickSort(a, l + 1, high);
    }

    /**
     * 快速排序
     * 递归形式
     * 第一记录为枢轴
     * @param a 需要排序的数组
     */
    public static void QuickSort(int a[]) {
        QuickSort(a, 0, a.length-1);
    }

    /**
     * 二路归并排序
     * 递归
     * 稳定
     * @param a 需要排序的数组
     * @param low 数组的起始下标
     * @param high 数组的结束下标
     */
    public static void MergeSort(int a[], int low, int high) {
        if(low >= high) return;

        int mid = (low + high) / 2;
        MergeSort(a, low, mid);
        MergeSort(a, mid + 1, high);

        int[] b = new int[high - low + 1];
        int i, j, k = 0;
        for(i = low, j = mid + 1; i <= mid && j <= high; ){
            if(a[i] < a[j])
                b[k++] = a[i++];
            else
                b[k++] = a[j++];
        }
        while(i <= mid)
            b[k++] = a[i++];
        while(j <= high)
            b[k++] = a[j++];

        while(low <= high)
            a[high--] = b[--k];
    }

    /**
     * 二路归并排序
     * 递归
     * @param a 需要排序的数组
     */
    public static void MergeSort(int a[]) {
        MergeSort(a, 0, a.length-1);
    }

    /**
     * 堆排序
     * 不稳定
     * @param a 需要排序的数组
     */
    public static void HeapSort(int[] a){
        for(int i = a.length / 2; i > 0 ; i--)
            percDown(a, i, a.length);
        for(int i = a.length-1; i > 0; i--) {
            int tem = a[0];
            a[0] = a[i];
            a[i] = tem;

            percDown(a, 0, i);
        }
    }

    /**
     * 堆的下滤操作
     * @param a 需要排序的数组
     * @param i 下滤的位置
     * @param n 堆的大小
     */
    public static void percDown(int[] a, int i, int n) {
        int tem = a[i];
        for(int child = 2 * i + 1; child < n; i = child, child = 2 * child + 1) {
            if(child != n-1 && a[child] < a[child+1])
                child++;

            if (tem < a[child])
                a[i] = a[child];
            else
                break;
        }
        a[i] = tem;
    }

    /**
     * 希尔排序
     * 增量序列为 a.length / 2, a.length / 4, ... 1
     * 不稳定
     * @param a 需要排序的数组
     */
    public static void ShellSort(int[] a) {
        for(int gap = a.length / 2; gap > 0; gap /= 2) {
            for(int i = gap; i < a.length; i++) {
                int tem = a[i], j;
                for(j = i; j >= gap && tem < a[j - gap]; j -= gap)
                    a[j] = a[j - gap];
                a[j] = tem;
            }
        }
    }
}