基于java的数据结构学习手记11--递归法数组归并排序

一.2个有序数组的归并排序    

 A,B有序数组的归并排序就是同时从小到大的扫描2个数组，把数值小的数字赋值给一个新的数组C，依次直到A或者B内容都赋值完毕，把另一个数组剩余的值依次插入给C数组。

二.一个无序数组的归并排序

   对于一个无序的数组排序，可以使用二分法，把它分成2个无序数组，然后使用递归2-》4，4-》8（个数组）的分裂，假定说只有一个元素的数组是有序的，这样最终问题将归结为解决2个有序数组的归并排序问题，即而解决问题。

  

Code:

1. package recursive;  
2. //demostrate recursive merge sort  
3. //  
4. public class Darray {  
5.     private long[]theArray;             //数组  
6.     private int nElems;                //数组大小  
7. //  
8.     public Darray(int max)             //初始化  
9.     {  
10.         theArray=new long[max];  
11.         nElems=0;  
12.     }  
13. /  
14.     public void insert(long value)    //插入  
15.     {  
16.         theArray[nElems]=value;  
17.         nElems++;  
18.     }  
19. /     
20.      public void display()          //显示  
21.      {  
22.          for(int j=0;j<nElems;j++)  
23.              System.out.print(theArray[j]+" ");  
24.          System.out.println("");  
25.      }  
26. ///  
27.      public void mergeSort()       //归并排序  
28.      {  
29.          long[]workSpace=new long[nElems];    //构造一个和theArray同样大小的数组  
30.          recMergeSort(workSpace,0,nElems-1);  //子归并  
31.      }  
32. //  
33.      private void recMergeSort(long[]workSpace,int lowerBound,  
34.                                 int upperBound)  
35.       {  
36.             if(lowerBound==upperBound)//if range is 1,return itself  
37.             return;  
38.             else  
39.             {  
40.               int mid=(lowerBound+upperBound)/2;//find midpoint  
41.               recMergeSort(workSpace,lowerBound,mid);//sort lower half  
42.               recMergeSort(workSpace,mid+1,upperBound);//sort high half  
43.               merge(workSpace,lowerBound,mid+1,upperBound);//归并高低两部  
44.             }  
45.   
46.        }  
47.   
48. ///  
49.      private void merge(long[] workSpace,int lowPtr,int highPtr,int upperBound)//归并  
50.      {  
51.          int j=0;  
52.          int lowerBound=lowPtr;                               //低端指针  
53.          int mid=highPtr-1;                                   //高端指针  
54.          int n=upperBound-lowerBound+1;                       //总个数  
55.            
56.          while(lowPtr<=mid&&highPtr<=upperBound)              //低端指针上限为mid,高端指针上限为upperBound  
57.          if(theArray[lowPtr]<theArray[highPtr])  
58.              workSpace[j++]=theArray[lowPtr++];  
59.          else  
60.              workSpace[j++]=theArray[highPtr++];  
61.            
62.          while(lowPtr<=mid)                                     //高端结束，把剩余的低端数组直接赋值  
63.              workSpace[j++]=theArray[lowPtr++];  
64.          while(highPtr<=upperBound)                            //低端结束，把剩余的高端数组直接赋值  
65.              workSpace[j++]=theArray[highPtr++];  
66.          for(int i=0;i<n;i++)                                  //把workSpace内存赋值给theArray  
67.              theArray[lowerBound+i]=workSpace[i];          
68.      }  
69. }  

Code:

1. package recursive;  
2.   
3. public class MergeSortApp {  
4.   
5.     /** 
6.      * @param args 
7.      */  
8.     public static void main(String[] args) {  
9.         // TODO Auto-generated method stub  
10.         int maxSize=100;  
11.         Darray arr;  
12.         arr=new Darray(maxSize);  
13.         arr.insert(64);  
14.         arr.insert(21);  
15.         arr.insert(33);  
16.         arr.insert(70);  
17.         arr.insert(12);  
18.         arr.insert(85);  
19.         arr.insert(44);  
20.         arr.insert(3);  
21.         arr.insert(99);  
22.         arr.insert(0);  
23.         arr.insert(108);  
24.         arr.insert(36);  
25.           
26.         arr.display();  
27.         arr.mergeSort();  
28.         arr.display();  
29.   
30.     }  
31.   
32. }  

结果如下：

Code:

1. 64 21 33 70 12 85 44 3 99 0 108 36   
2. 0 3 12 21 33 36 44 64 70 85 99 108   

PS：时间复杂度为N*logN