排序算法-归并排序

归并排序的思想是：将两个已经排序的数组，重新排序到一个数组中，所以只需要一趟，就能完成排序。
比如说有数组{14,20，50}和{45,68,96}和一个新数组{}，进行从小到大排序；
第一趟下来，因为14比45小，三个数组分别为{20,50}，{45,68,96},和新数组{14}；
第二趟下来，因为20比45小，三个数组分别为{50}，{45,68,96},和新数组{14，20}
第三趟下来，因为45比50小，三个数组分别为{50}，{68,96},和新数组{14，20,50}；
接下来借不说了，总之是把两个排序过的数组，归并到一个新数组中。
代码

package com.creat.sort;

import org.junit.Test;

/**
 * Created by whz on 2017/8/23.
 */
public class MergeSort {
    @Test
    public void test(){
        Integer[] array = new Integer[]{10,54,55,47,50,20,41,33,40,28,70,27};
        Integer[] newArray = new Integer[array.length];
        sort(array,newArray,0,array.length-1);
        for(int i = 0; i < newArray.length; i++){
            System.out.print(newArray[i]+" ");
        }
        System.out.println();
    }
    public static <T extends Comparable<? super T>> void sort(T[] array,T[] newArray, int left, int right){
        if(right > left){
            int middle = ( right + left ) / 2;
            T[] l = (T[]) new Comparable[middle - left + 1];
            T[] r = (T[]) new Comparable[right - middle];
            sort(array, l, left, middle);
            sort(array, r, middle+1, right);
            mergeSort(l, r, newArray);
        }else {
            newArray[0]=array[right];
        }
    }

    private static <T extends Comparable<? super T>> void mergeSort(T[] l, T[] r, T[] newArray){
        int left = 0;
        int right = 0;
        for(int i = 0;i < newArray.length; i++){
            if(left >= l.length){
                newArray[i] = r[right++];
            }else if(right >= r.length){
                newArray[i] = l[left++];
            }else if(l[left].compareTo(r[right]) < 0 ){
                newArray[i] = l[left++];
            }else {
                newArray[i] = r[right++];
            }
        }
    }
}

归并排序的时间复杂度为O（Nlog2N），归并排序在交换元素的时间上相对节省，再是在动态生成对象时会耗费时间。