归并排序（JAVA版）

归并排序

归并排序用了“分治法”

分治法的基本思想：主要分为3步

(1)    分(devide)：将问题分解成小问题

(2)    治(conquer)：递归地解决这些小问题

(3)    和(combine)：将各个小问题的解决方案进行合并，得到整个问题的解决方案

合并排序（MERGESORT）是又一类不同的排序方法，合并的含义就是将两个或两个以上的有序数据序列合并成一个新的有序数据序列，因此它又叫归并算法。它的基本思想就是假设数组A有N个元素，那么可以看成数组A是又N个有序的子序列组成，每个子序列的长度为1，然后再两两合并，得到了一个 N/2  个长度为2或1的有序子序列，再两两合并，如此重复，值得得到一个长度为N的有序数据序列为止，这种排序方法称为2—路合并排序。

合并算法的核心操作就是将一维数组中前后相邻的两个两个有序序列合并成一个有序序列。合并算法也可以采用递归算法来实现，形式上较为简单,但实用性很差。合并算法的合并次数是一个非常重要的量,根据计算当数组中有3到4个元素时,合并次数是2次,当有5到8个元素时,合并次数是3次,当有9到16个元素时,合并次数是4次，按照这一规律,当有N个子序列时可以推断出合并的次数是X(2  >=N,符合此条件的最小那个X)。

其时间复杂度为：O(nlogn).所需辅助存储空间为：O(n)

//mergeSort.java

//归并排序

public class mergeSort {

 

       public static void main(String[] args)

       {

           int maxSize=100;

           ArrayMerge arr;

           arr=new ArrayMerge(maxSize);

           arr.insert(77);

           arr.insert(99);

           arr.insert(44);

           arr.insert(55);

           arr.insert(22);

           arr.insert(88);

           arr.insert(11);

           arr.insert(00);

           arr.insert(66);

           arr.insert(33);

           arr.display();

           arr.mergeSort();

           arr.display();

       }

    }

 

    class ArrayMerge

    {

       private int[] a;

       private int nElems;

      

       //构造函数

       public ArrayMerge(int max)

       {

           a=newint[max];

           nElems=0;

       }

      

       //插入数据

       public void insert(int value)

       {

           a[nElems]=value;

           nElems++;

       }

      

      

       //显示数组数据

       public void display()

       {

           for(int j=0;j<nElems;j++)

              System.out.println(a[j]+" ");

              System.out.println(" ");

       }  

      

       private void merge(int[] workSpace,int lowPtr,int highPtr,int upperBound)

       {

           int j=0;

           int lowerBound=lowPtr;

           int mid=highPtr-1;

           int n=upperBound-lowerBound+1;

           while(lowPtr<=mid&&highPtr<=upperBound)

           {

              if(a[lowPtr]<a[highPtr])

                  workSpace[j++]=a[lowPtr++];

              else

                  workSpace[j++]=a[highPtr++];

           }

           while(lowPtr<=mid)

           {

              workSpace[j++]=a[lowPtr++];

           }

           while(highPtr<=upperBound)

           {

              workSpace[j++]=a[highPtr++];

           }

           for(j=0;j<n;j++)

              a[lowerBound+j]=workSpace[j];

       }

       public void reMergeSort(int[] workSpace,int lowerBound,int upperBound)

       {

           if(lowerBound==upperBound)//只有一个元素

              return;

           else

           {

              int mid=(lowerBound+upperBound)/2;

              reMergeSort(workSpace,lowerBound,mid);

              reMergeSort(workSpace,mid+1,upperBound);

              merge(workSpace,lowerBound,mid+1,upperBound);

           }

       }

       public void mergeSort()

       {

           int[] workSpace=newint[nElems];

           reMergeSort(workSpace,0,nElems-1);

       }

 

}

归并排序分析：

时间复杂度：o(N*logN)