归并排序

归并排序算法稳定，数组需要O(n)的额外空间，链表需要O(log(n))的额外空间，时间复杂度为O(nlog(n))

NOTE: 新数组的创建和数据拷贝是硬伤，我尝试了一下只申请一个workspace，应该还不错吧，没有理论论证

代码：

package sorts;

import java.util.Arrays;
import java.util.Random;

public class MergeSort {

    public static <T extends Comparable<T>> void sort(T[] array) {
        T[] workspace = (T[])new Comparable[array.length]; // only 1 workspace is claimed, no more copies
        recMerge(array, 0, array.length-1, workspace);
    }
    
    /**
     * recursively merge
     * */
    private static <T extends Comparable<T>> void recMerge(T[] array,
            int lowerBound, int upperBound, T[] wp) {
        if (lowerBound == upperBound) {
            return;
        } else {
            int mid = ((lowerBound + upperBound)>>1); // (low + upper) / 2
            recMerge(array, lowerBound, mid, wp);
            recMerge(array, mid+1, upperBound, wp);
            merge(array, lowerBound, mid, upperBound, wp);
        }
    }
    /**
     * Merge two sorted array into one.
     * */
    private static <T extends Comparable<T>> void merge(T[] array,
            int lowerBound, int mid, int upperBound, T[] wp) {
        int lowIndex = lowerBound;
        int highIndex = mid + 1;
        int j = 0; // workspace index
        // merge them into one array
        while (lowIndex <= mid && highIndex <= upperBound) {
            if (array[lowIndex].compareTo(array[highIndex]) < 0) {
                wp[j++] = array[lowIndex++];
            } else {
                wp[j++] = array[highIndex++];
            }
        }
        // copy the rest
        while (lowIndex <= mid) {
            wp[j++] = array[lowIndex++];
        }
        while (highIndex <= upperBound) {
            wp[j++] = array[highIndex++];
        }
        // copy the merged array into the original array
        int n = upperBound - lowerBound + 1;
        for (int i = 0; i < n; i++) {
            array[lowerBound+i] = wp[i];
        }
    }
    
    // test
    public static void main(String[] args) {
        Random random = new Random();
        int num = 10;
        int bound = 100;
        Integer[] a = new Integer[num];
        for (int i = 0; i < num; i++) {
            a[i] = random.nextInt(bound);
        }
        MergeSort.sort(a);
        System.out.println(Arrays.toString(a));
    }

}