复习一：数组（6）-归并排序

归并排序是建立在归并操作上的一种有效，稳定的排序算法。
该算法是采用分治法的一个非常典型的应用。
归并排序的实现由两种方法：

1. 自上而下的递归
2. 自下而上的迭代

思路：

1. 将这个数组分成一半，直到每一部分
2. 把左边的数组排序，右边的数组排序。当我们对左边的数组和右边的素组进行排序的时候，再分别将左边的数组和右边的数组分成一半，然后对每一个部分先排序，再归并
3. 对于上面的每一个部分呢，我们依然是先将他们分半，再归并
4. 归并到上一个层级之后继续归并，归并到更高的层级，直至最后归并完成

算法实现：

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤 3 直到某一指针达到序列尾
5. 将另一序列剩下的所有元素直接复制到合并序列尾

public static void sort(int [] arr,int left,int mid,int right) {
        int [] temp = new int[right-left+1]; //临时数组，用来保存每次合并年之后的结果
        int i = left;
        int j = mid+1;
        int k = 0;//临时数组的初始下标
        //这个while循环能够初步筛选出待合并的了两个子序列中的较小数
        while(i<=mid&&j<=right) {
            if(arr[i]<=arr[j]) {
                temp[k++] = arr[i++];
            }else {
                temp[k++] = arr[j++];
            }
        }
        //将左边序列中剩余的数放入临时数组
        while(i<=mid) {
            temp[k++] = arr[i++];
        }
        //将右边序列中剩余的数放入临时数组
        while(j<=right) {
            temp[k++] = arr[j++];
        }
        //将临时数组中的元素位置对应到真真实的数组中
        for(int m=0;m<temp.length;m++) {
            arr[m+left] = temp[m];
        }
    }
    public static void mergeSort(int [] arr,int left,int right) {
        int mid = (left+right)/2; //中间下标
        if(left<right) {
            mergeSort(arr,left,mid);//递归拆分左边
            mergeSort(arr,mid+1,right);//递归拆分右边
            sort(arr,left,mid,right);//合并左右
        }
    }
    public static void main(String[] args) {
        int [] arr= {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("原arr数组为："+Arrays.toString(arr));
        mergeSort(arr,0,arr.length-1);
        System.out.println("归并排序后arr为："+Arrays.toString(arr));
    }

运行结果：

时间复杂度： O(nlogn)
对长度为n的文件，需进行趟二路归并，每趟归并的时间为O(n)，故其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlgn)
空间复杂度： O(n)
需要一个辅助向量来暂存两有序子文件归并的结果，故其辅助空间复杂度为O(n)，
稳定性： 稳定