經典排序算法--歸並排序

基本思想：

　　歸並排序是將兩個或兩個以上的有序表組合成一個新的有序表。其基本思想是：先將N個數據看成N個長度為1的表，將相鄰兩個表合並，得到長度為2的N/2個有序表，進一步將相鄰的表合並，得到長度為4的N/4個有序表，以此類推，知道所有數據合並成一個長度為N的有序表位置。沒一次歸並稱為一趟。

　　要解決歸並問題，首先要解決兩兩歸並問題（兩個有序表合並成一個有序表），其java實現為：

    
    public static void mergeTwo(int[] data,int first,int mid,int last,int[] tmp){
        
        //把data[first]-data[mid]當做第一個有序序列 ，這里設為A
        //把data[mid+1]-data[last]當做第二個有序序列,這里設為B
        //將兩個有序序列合並，形成的新序列為data[first]-data[last]
        int i = first, j = mid + 1;  
        int m = mid,   n = last;  
        int k = 0; 
        while(i<=m&&j<=n){
            //A序列和B序列依次從起始值開始比較
            //如果A序列值小，就將其移值tmp中
            //並且A下標i+1;tmp下標k+1
            if(data[i]<data[j]){
                tmp[k++] =data[i++];
            }else{
                //如果B序列值小，就將其移值tmp中
                //並且B下標i+1;tmp下標k+1
                tmp[k++] = data[j++];
            }
        }
        
        //如果A序列或者B序列已經全部移到tmp中
        //則剩余的另一個序列依次移到tmp中
        while(i<=m){
            tmp[k++] =data[i++];
        }
        while(j<=n){
            tmp[k++] = data[j++];
        }
        
        //遍歷tmp，將tmp中元素移會data，此時data[first]-data[last]為有序序列
        for (i = 0; i < k; i++)  {
            data[first + i] = tmp[i]; 
        }
    }

實現方法：

　　歸並排序有兩種實現方法：

　　1）自底向上

　　2）自頂向下

　　自底向上的基本思想是：第一趟歸並排序時，將待排序的文件R[1.....n]看做是n個長度為1的有序文件，將這些子文件兩兩歸並，若n為偶數，則得到n/2個長度為2的有序文件；若n為奇數，則最后一個子文件輪空（不參與歸並，直接進入下一趟歸並），估本趟歸並完成后，前n/2-1個有序子文件長度為2，單最后一個子文件長度仍未1；第二趟歸並則是將第一趟歸並所得到的n/2個有序文件兩兩歸並，如此反復，知道得到最后長度為n的有序文件位置。

　　其程序實現：

package sortDemo;

public class MargeSort {
    
    public static void main(String[] args) {
        int[] sort ={3,2,1,4,6,5,8,9,10,7} ;
        System.out.println("排序前：");
        print(sort);
        int[] tmp = new int[sort.length];
        mergeSort(sort,0,sort.length-1,tmp);
        System.out.println("\n排序后：");
        print(sort);
    }
    
    public static void mergeSort(int[] data,int first,int last,int[] tmp){
        if(first<last){
            int mid = (last-first)/2+first;
            //使左側有序
            mergeSort(data,first,mid,tmp);
            //使右側有序
            mergeSort(data,mid+1,last,tmp);
            //合並兩個有序的子序列
            mergeTwo(data, first, mid, last, tmp);
        }
    }
    
    public static void mergeTwo(int[] data,int first,int mid,int last,int[] tmp){
        
        //把data[first]-data[mid]當做第一個有序序列 ，這里設為A
        //把data[mid+1]-data[last]當做第二個有序序列,這里設為B
        //將兩個有序序列合並，形成的新序列為data[first]-data[last]
        int i = first, j = mid + 1;  
        int m = mid,   n = last;  
        int k = 0; 
        while(i<=m&&j<=n){
            //A序列和B序列依次從起始值開始比較
            //如果A序列值小，就將其移值tmp中
            //並且A下標i+1;tmp下標k+1
            if(data[i]<data[j]){
                tmp[k++] =data[i++];
            }else{
                //如果B序列值小，就將其移值tmp中
                //並且B下標i+1;tmp下標k+1
                tmp[k++] = data[j++];
            }
        }
        
        //如果A序列或者B序列已經全部移到tmp中
        //則剩余的另一個序列依次移到tmp中
        while(i<=m){
            tmp[k++] =data[i++];
        }
        while(j<=n){
            tmp[k++] = data[j++];
        }
        
        //遍歷tmp，將tmp中元素移會data，此時data[first]-data[last]為有序序列
        for (i = 0; i < k; i++)  {
            data[first + i] = tmp[i]; 
        }
    }
    
    public static void print(int[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }
}

算法分析：

　　（1）穩定性

　　歸並排序是一種穩定的排序。

　　（2）存儲結構要求

　　可用順序存儲結構，也易於在鏈表上實現。

　　（3） 時間復雜度

　　對長度為n的文件，需要進行[log2n]趟二路歸並，沒趟歸並的時間為O(n)，故其時間復雜度無論是在最好情況下還是最壞情況下均是O(nlgn).