歸併排序

兩個有序的子列的歸併
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("------空間不足-------");
        }
    }