排序算法：O(Nlog(N))

1.归并排序

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
具体过程可参照下图：

代码如下：

    /**
     * @param arr 待排序数组
     * @param n   数组长度
     */
    public static void mergeSort(int[] arr, int n) {
        mergeSort(arr, 0, n - 1);
    }

    /**
     * 递归使用归并排序，对arr[l.....r]的范围进行排序
     *
     * @param arr
     * @param l
     * @param r
     */
    private static void mergeSort(int[] arr, int l, int r) {
        if (l >= r) {//终止条件
            return;
        }
        int mid = l + (r - l) / 2;
        mergeSort(arr, l, mid);
        mergeSort(arr, mid + 1, r);
        merge(arr, l, mid, r);
    }

    /**
     * 归并操作，对arr[l...mid]和arr[mid+1...r]两部分进行归并
     *
     * @param arr
     * @param l
     * @param mid
     * @param r
     */
    private static void merge(int[] arr, int l, int mid, int r) {
        int[] temps = new int[r - l + 1];
        for (int i = l; i <= r; i++) {
            temps[i - l] = arr[i];
        }
        int i = l, j = mid + 1;
        for (int k = l; k <= r; k++) {
            if (i > mid) {
                arr[k] = temps[j - l];
                j++;
            } else if (j > r) {
                arr[k] = temps[i - l];
                i++;
            }
            if (temps[i - l] < temps[j - l]) {
                arr[k] = temps[i - l];
                i++;
            } else {
                arr[k] = temps[j - l];
                j++;
            }
        }
    }

仔细观察整个归并排序过程，在进行merge操作前，如果是已经有序的话，可以取消这一次merge操作，提升性能。代码如下

    /**
     * 递归使用归并排序，对arr[l.....r]的范围进行排序
     *
     * @param arr
     * @param l
     * @param r
     */
    private static void mergeSort(int[] arr, int l, int r) {
        if (l >= r) {//终止条件
            return;
        }
        int mid = l + (r - l) / 2;
        mergeSort(arr, l, mid);
        mergeSort(arr, mid + 1, r);
        if (arr[mid] > arr[mid + 1]){
            merge(arr, l, mid, r);
        }

    }

这里还有一个优化思路，在归并排序过程中，要进行排序的长度很短时，可以用插入排序代替，优化性能，在数组长度很短的时候，归并排序的递归操作就会比插入排序更消耗性能。改进代码如下：

    /**
     * 递归使用归并排序，对arr[l.....r]的范围进行排序
     *
     * @param arr
     * @param l
     * @param r
     */
    private static void mergeSort(int[] arr, int l, int r) {
        /*if (l >= r) {//终止条件
            return;
        }*/
        if (r - l <= 5){//这里的优化是在有序数组数组长度很短时，插入排序比归并排序性能更好
            insertionSort(arr,l,r);
        }
        int mid = l + (r - l) / 2;
        mergeSort(arr, l, mid);
        mergeSort(arr, mid + 1, r);
        if (arr[mid] > arr[mid + 1]){
            merge(arr, l, mid, r);
        }
    }
    
    /**
     * 在arr[l...r]范围内做插入排序
     * @param arr
     * @param l
     * @param r
     */
    private static void insertionSort(int[] arr,int l,int r){
        for (int i = l + 1;i <= r ; i ++){
            //寻找元素arr[i]合适的插入位置
            int e = arr[i];
            int j;
            for (j = i; j > l ; j --){
                if (arr[j - 1] > e){
                    arr[j] = arr[j - 1];
                }else {
                    break;
                }
            }
            arr[j] = e;
        }
        return;
    }