归并排序

两个有序的子列的归并
1 13 24 26
2 15 27 38
一个空的数组
先用1与2比，将小的放进数组中，然后第一个数组的索引++，空的数组索引++。
所以可以知道时间复杂度为O(n)

    //归并排序   arr1传入数组，arr2临时数组,left左边起始位置，right右边起始位置，rightend右边终点位置
    public static void MergeSort(int arr1[],int []arr2,int left,int right,int rightend){
        int leftend=right-1;//左边终点位置
        int Tmp=left;//存放结果的数组的初始位置
        int NumElements=rightend-left+1;
        while(left<=leftend&&right<=rightend) {
            if(arr1[left]<=arr1[right]) {
                arr2[Tmp++]=arr1[left++];
            }
            else {
                arr2[Tmp++]=arr1[right++];
            }
        }
        while(left<=leftend) {//复制左边剩下的
            arr2[Tmp++]=arr1[left++];
        }
        while(right<=rightend) {//复制左边剩下的
            arr2[Tmp++]=arr1[right++];
        }
        for(int i=0;i<NumElements;i++,rightend--) {/*rightend使用它的目的就是是不变的，然后左边的一直在++，left在变化，最后不清楚指在哪里了，归并完成后将结果复制回arr1*/
            arr1[rightend]=arr2[rightend];
        }
    }

分而治之：
可以得到T（N）=O（NlogN）
归并排序在外排序的时候才是最有用的工具

    //归并排序   arr1传入数组，arr2临时数组,left左边起始位置，right右边起始位置，rightend右边终点位置
    public static void MergeSort(int arr1[],int []arr2,int left,int right,int rightend){
        int leftend=right-1;//左边终点位置
        int Tmp=left;//存放结果的数组的初始位置
        int NumElements=rightend-left+1;
        while(left<=leftend&&right<=rightend) {
            if(arr1[left]<=arr1[right]) {
                arr2[Tmp++]=arr1[left++];
            }
            else {
                arr2[Tmp++]=arr1[right++];
            }
        }
        while(left<=leftend) {//复制左边剩下的
            arr2[Tmp++]=arr1[left++];
        }
        while(right<=rightend) {//复制左边剩下的
            arr2[Tmp++]=arr1[right++];
        }
        for(int i=0;i<NumElements;i++,rightend--) {/*rightend使用它的目的就是是不变的，然后左边的一直在++，
        left在变化，最后不清楚指在哪里了,归并完成后将结果复制回arr1*/
            arr1[rightend]=arr2[rightend];
        }
    }
    //归并排序   arr1传入数组，arr2临时数组,left为arr1的左边起始位置，rightend为arr1右边终点位置
    public static void MergeSort1(int arr1[],int []arr2,int left,int rightend){
        int center;
        if(left<rightend) {
            center=(left+rightend)/2;//计算中点位置
            MergeSort1(arr1,arr2,left,center);//对左边排序
            MergeSort1(arr1,arr2,center+1,rightend);//对右边排序
            MergeSort(arr1,arr2,left,center+1,rightend);//对排好序的做处理
        }
    }
    public static void MergeSort2(int arr[]) {
        int arr2[]=new int[arr.length];
        if(arr2!=null) {
            MergeSort1(arr,arr2,0,arr.length-1);
        }
        else {
            System.out.println("------空间不足-------");
        }
    }
    //非递归算法
    public static void MergeSort3(int arr1[],int []arr2,int length1) {//length1表示当前有序子列的长度
        for(int i=0;i<arr1.length;i+=2*length1) {
            MergeSort(arr1, arr2, i, i+length1, i+2*length1-1);//这里是把arr1中的元素归并到arr2中，所以最后一句不要
            if(i+length1<arr1.length) {//归并最后两个子列
                MergeSort(arr1, arr2, i, i+length1, arr1.length-1);
            }else {
                for(int j=i;j<arr1.length;j++)arr2[j]=arr1[j];
            }

        }
    }
    public static void MergeSort4(int arr[]) {
        int length1=1;
        int arr2[]=new int[arr.length];
        if(arr2!=null) {
            while(length1<arr.length){
                MergeSort3(arr,arr2,length1);
                length1 *=2;
                MergeSort3(arr2,arr,length1);
                length1 *=2;
            }
        }
        else {
            System.out.println("------空间不足-------");
        }
    }