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;
}
}
}
}