归并排序算法

归并排序思想：将待排序的元素分成大小大致相同的2个子集合，分别对2个子集合进行排序，最终将排序好的子集合合并成为索要要求的排好序的集合。

step1：把待排序的n个记录看作是长度为1的有序序列。将相邻的子序列两两归并成为长度为2或1的有序序列。

step2：把得到的n/2个长度为2的有序子序列在归并为长度为2*2的有序序列。

step3：按step2的方式，重复对相邻的有序子序列进行归并操作，直到成为一个有序序列为止。

package com.mergesort.yy;  
/** 
 * 归并排序 
 *@author yuyang_csu 
 *@data 2013-4-6 
 */  
public class MergeSort {  
    private int [] arr;  
      
    //重载构造方法  
    public MergeSort(int[]arr){  
        this.arr = arr;  
    }  
      
    //重载mergeSort方法  
    public void mergeSort(){  
        int left = 0;  
        int right = arr.length-1;  
        mergeSort(left,right);  
    }  
      
    //递归调用归并算法  
    public void mergeSort(int left,int right){  
        if(left<right){  
            int mid = (right+left)/2;  
            mergeSort(left,mid);  
            mergeSort(mid+1,right);  
            merge(left,mid,right);  
        }  
    }  
      
    /** 
     * 归并方法 
     * @param left:数组的起始下标 
     * @param mid：中间元素的下标 
     * @param right：数组最后一个元素的下标 
     */  
    public void merge(int left,int mid,int right){  
        int begin1,end1,begin2,end2;  
        begin1 = left;  
        end1 = mid;  
        begin2 = mid+1;  
        end2 = right;  
          
        //声明要将合并后数组存放的内存空间  
        int [] tmp = new int[right-left+1];  
        //记录插入到的位置  
        int k = 0;  
        //不断比较两个分开数组中起始元素的大小，将小元素添加到新数组里  
        while(begin1<=end1 && begin2<=end2){  
            if(arr[begin1]<=arr[begin2]){  
                tmp[k++] = arr[begin1++];  
            }else{  
                tmp[k++] = arr[begin2++];  
            }  
        }  
        //比较完两个数组后，若一个数组中元素有剩余，则将剩余元素添加到新数组末尾  
        while(begin1<=end1){  
            tmp[k++] = arr[begin1++];  
        }  
          
        while(begin2 <= end2){  
            tmp[k++] = arr[begin2++];  
        }  
          
        //copy数组  
        for(int i = 0;i<(right-left+1);i++){  
            arr[left+i] = tmp[i];  
        }  
    }  
      
    //显示属于元素的方法  
    public void display(){  
        for(int i = 0;i<arr.length;i++){  
            System.out.print(arr[i]+"  ");  
        }  
    }  
      
    //主函数  
    public static void main(String[] args) {  
        int [] arr= {49,38,65,97,76,13,27};  
        MergeSort m = new MergeSort(arr);  
        m.mergeSort();  
        m.display();  
    }  
}  

时间复杂度分析：当n<=1时，为O（1）；当n>1时，T（n）=2T（n/2）+O(N)。经过推导得出，当n>1时，时间复杂度为O（N*logN）。

稳定性分析： 归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定性。那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。