1. package com.tw.dst.recursive;  
  2.  
  3. /**    
  4.  * <p>  
  5.  * 算法学习 ----递归  
  6.  * 概念介绍:  
  7.  * 归并排序:归并算法的中心是归并两个已经有序的数组,并且递归调用归并操作。     
  8.  * 归并排序优点和缺点:比简单排序在速度上快很多;归并排序会占用双倍的存储空间。    
  9.  * 归并排序的效率:归并排序的时间复杂度是 O(N*LogN);简单排序的复杂度是O(N2)。</p>  
  10.  * @author tangw 2010-12-13  
  11.  */    
  12. public class MergeRecursion3 {     
  13.     
  14.     private long[] theArray;     
  15.     private int nElems;     
  16.     /**  
  17.      * <p>初始化数组</p>   
  18.      * @param max  
  19.      */ 
  20.     public MergeRecursion3(int max) {    
  21.         theArray = new long[max];     
  22.         nElems = 0;     
  23.     }     
  24.     
  25.     /**  
  26.      * <p>插入数据</p>  
  27.      * @param value  
  28.      */ 
  29.     public void insert(long value) {     
  30.         theArray[nElems] = value;     
  31.         nElems++;     
  32.     }     
  33.     /**  
  34.      * <p>显示数组中的数据</p>  
  35.      */ 
  36.     public void display() {  
  37.         for (int j = 0; j < nElems; j++) {     
  38.             System.out.print(theArray[j]+","+" ");     
  39.         }     
  40.     }     
  41.     /**    
  42.      * <p>归并排序算法</p>  
  43.      */    
  44.     public void mergeSort() {     
  45.         long[] workSpace = new long[nElems];//创建一个工作数组,用于排序操作使用     
  46.         recMergeSort(workSpace, 0, nElems - 1);//执行归并排序操作     
  47.     }     
  48.          
  49.     /**  
  50.      * <p>递归分割数据到基本单位 </p>   
  51.      * @param workSpace  
  52.      * @param lowerBound  
  53.      * @param upperBound  
  54.      */ 
  55.     private void recMergeSort(long[] workSpace, int lowerBound, int upperBound) {     
  56.         if (lowerBound == upperBound) {     
  57.             return;     
  58.         } else {     
  59.             int mid = (lowerBound + upperBound) / 2;     
  60.             recMergeSort(workSpace, lowerBound, mid);     
  61.             recMergeSort(workSpace, mid + 1, upperBound);     
  62.             merge(workSpace, lowerBound, mid + 1, upperBound);     
  63.         }     
  64.     }     
  65.          
  66.     /**  
  67.      * 归并操作将基本单位归并成整个有序的数组   
  68.      * @param workSpace  
  69.      * @param lowPtr  
  70.      * @param highPtr  
  71.      * @param upperBound  
  72.      */ 
  73.     private void merge(long[] workSpace, int lowPtr, int highPtr, int upperBound) {     
  74.         int j = 0;     
  75.         int lowerBound = lowPtr;     
  76.         int mid = highPtr - 1;     
  77.         int n = upperBound - lowerBound + 1;     
  78.     
  79.         while (lowPtr <= mid && highPtr <= upperBound) {     
  80.             if (theArray[lowPtr] < theArray[highPtr]) {     
  81.                 workSpace[j++] = theArray[lowPtr++];     
  82.             } else {     
  83.                 workSpace[j++] = theArray[highPtr++];     
  84.             }     
  85.         }     
  86.         while (lowPtr <= mid) {     
  87.             workSpace[j++] = theArray[lowPtr++];     
  88.         }     
  89.         while (highPtr <= upperBound) {     
  90.             workSpace[j++] = theArray[highPtr++];     
  91.         }     
  92.         for (j = 0; j < n; j++) {     
  93.             theArray[lowerBound + j] = workSpace[j];     
  94.         }     
  95.     }  
  96.       
  97.       
  98.     public void println(String str){     
  99.             System.out.println(str);     
  100.     }     
  101.       
  102.       
  103.     public static void main(String[] args) {     
  104.         int maxSize = 100;     
  105.         MergeRecursion3 arr = new MergeRecursion3(maxSize);     
  106.         /**    
  107.          * 插入值到数组    
  108.          */    
  109.         arr.insert(64);     
  110.         arr.insert(21);     
  111.         arr.insert(11);     
  112.         arr.insert(33);     
  113.         arr.insert(12);     
  114.         arr.insert(85);     
  115.         arr.insert(44);     
  116.         arr.insert(99);     
  117.         arr.insert(3);     
  118.         arr.insert(0);     
  119.         arr.insert(108);     
  120.         arr.insert(36);     
  121.              
  122.         arr.println("显示排序前数据:");     
  123.         arr.display();     
  124.         arr.println("");       
  125.              
  126.         arr.mergeSort();     
  127.              
  128.         arr.println("显示排序后数据:");     
  129.         arr.display();     
  130.         arr.println("");       
  131.     }   
  132. }  
  133.  
  134. /**    
  135.  *     
  136.  * 显示排序前数据:    
  137.  * 64, 21, 11, 33, 12, 85, 44, 99, 3, 0, 108, 36,     
  138.  * 显示排序后数据:    
  139.  * 0, 3, 11, 12, 21, 33, 36, 44, 64, 85, 99, 108,    
  140.  */    
  141.     
  142. /**    
  143.  * 总结:    
  144.  * 归并排序比简单排序的效率高很多  
  145.  */