自底向上的归并排序-转自算法C语言实现

package cn.ccnu.lzc;

import java.util.Random;

public class DownTopTwoWayMergeSort {

	/**
	 * @param args
	 *  自底向上的归并排序：归并排序主要是完成将若干个有序子序列合并成一个
	 *  完整的有序子序列；自底向上的排序是归并排序的一种实现方式，将一个无
	 *  序的N长数组切个成N个有序子序列，然后再两两合并，然后再将合并后的N/2
	 *  （或者N/2 + 1）个子序列继续进行两两合并，以此类推得到一个完整的有序数组。
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int maxSize=16;
		TArray arr=new TArray(maxSize);
		for(int i=0;i<maxSize;i++){
			int n=new Random().nextInt(100);
			arr.insert(n);
		}
		arr.display();
		arr.MergeSort();
		arr.display();
	}

}
class TArray{
	private int[] theArray;
	private int nElems;
	public TArray(int max){
		theArray=new int[max];
		nElems=0;
	}
	public void insert(int value){
		theArray[nElems++]=value;
	}
	public void display(){
		for(int i:theArray){
			System.out.print(i+" ");
		}
		System.out.println();
	}
	public void MergeSort(){
		int[] workspace=new int[nElems];
		recMergeSort(workspace,0,nElems-1);
	}
	private void recMergeSort(int[] workspace, int lowerBound, int upperBound) {
		// TODO Auto-generated method stub
		int i,step;
		for(step=1;step<upperBound;step=2*step){
			for(i=0;i<=upperBound-step;i+=2*step){
				Merge(workspace,i,i+step,min(i+2*step-1,upperBound));
			}
		}
		
	}
	private void Merge(int[] workspace, int lowPtr, int highPtr, int upperBound) {
		// TODO Auto-generated method stub
		int lowBound=lowPtr;
		int mid=highPtr-1;
		int j=0;
		int n=upperBound-lowBound+1;
		while(lowPtr<=mid&&highPtr<=upperBound){
			if(theArray[lowPtr]<=theArray[highPtr]){
				workspace[j++]=theArray[lowPtr++];
			}else{
				workspace[j++]=theArray[highPtr++];
			}
		}
		while(lowPtr<=mid){
			workspace[j++]=theArray[lowPtr++];
		}
		while(highPtr<=upperBound){
			workspace[j++]=theArray[highPtr++];
		}
		for(j=0;j<n;j++){
			theArray[lowBound++]=workspace[j];
		}
	}
	private int min(int i, int upperBound) {
		// TODO Auto-generated method stub
		return (i<upperBound)?i:upperBound;
	}

}