归并排序

归并排序比简单排序有效率的多，归并排序的时间复杂度只要O(N*logN)，至少在速度上是这样的。
        归并排序的一个缺点就是它需要在存储器上有另一个大小等于被排序的数据项的数目的数组。如果初始数组几乎站满整个存储器，那么归并排序将不能工作。但是有足够的空间，归并排序会是一个很好的选择。
        归并两个有序数组A，B，生成第三个数组C，数组C包含A，B中的所有数据项。
        假设有两个有序数组，不要求有相同的大小。设数组A有四个数据项，B有6个数据项。他们被归并到C中，开始时数组C有10个空的存储空间。如下图：
        归并操作的步骤如下：

        归并代码：

                public static void merge(int[] arrayA,int sizeA,int[] arrayB,int sizeB,int[] arrayC){
                        int Aindex=0;int Bindex=0;int Cindex=0;
                        while(Aindex<sizeA &&Bindex<sizeB){
                                if(array[Aindex<arrayB[Bindex]){
                                        arrayC[Cindex++]=arrayA[Aindex++];
                                }
                                else{
                                        arrayC[Cindex++]=arrayB[Aindex++];
                                }
                        }
                        while(Aindex<sizeA){
                                arrayC[Cindex++]=arrayA[Aindex++];
                        }
                        while(Bindex<sizeB){
                                arrayC[Cindex++]=arrayB[Bindex++];
                        }
                }

        通过归并并进行排序：
                归并排序的简单思想就是把一个数组分成两半，排序一半，然后用merge()方法把两半归并成一个有序数组。如何对每一个部分排序呢？这一次将地
递归：把每一半都分成两个四分之一。对每一个四分之一部分排序，然后把他们归并成一个有序的一半。
                类似的，每一对八分之一部分归并成一个有序的四分之一，每一对十六分之一部分归并成一个有序的八分之一部分，以此类推。反复的分割数组，直到得到的字数组只含有一个数据项。这就是基值条件；设定只有一个数据项的数组是有序的。图示如下：

                递归代码：

</pre><pre name="code" class="java">                        private long[] theArray;
                        public void mergesort(int[] workspace,int lowBound,int uperBound){
                                if(lowBound==uperBound){
                                        return;
                                }
                                else{
                                        int mid=(lowBound+uperBound)/2;
                                        mergesort(workspace,lowBound,mid);
                                        mergesort(workspace,mid+1,uperBound);
                                        merge(workspace,lowbound,mid+1,uperBound);
                                }
                        }
                        public merge(int[] wokespace,int lowBound,int mid,int uperBound){
                                int low=lowBound;
                                int Mid=mid-1;
                                int uper=uperBound;
                                int j=0;
                                while(low<=Mid &&mid<=uper){
                                        if(theArray[low]<theArray[mid]){
                                                workspace[j++]=theArray[low++];
                                        }
                                        else{
                                                workspace[j++]=theArray[mid++];
                                        }
                                }
                                while(low<=Mid){
                                        workspace[j++]=theArray[low++];
                                }
                                while(mid<=uper){
                                        workspace(j++)=theArray[mid++];
                                }
                        }
                         public static void main(String[] args){
                                theArray=[.....];
                                int lowBound=0;
                                int uperBound=theArray.length-1;
                                long[] workspace=new long[theArray.length];
                                mergesort(workspace,lowBound,uperBound);
                                for(int i=0;i<workspace.length;i++){
                                        System.out.print(workspace[i]+" ");
                                }
                        }

        比较效率情况如下图所示：