Java排序法

Java排序法

快速排序法：

public class MyQuickSort {
	public int[] theArray;
	public int nElem;
	public MyQuickSort(int max){
		theArray = new int[max];
		nElem = 0;
	}
	public void insert(int value){
		theArray[nElem] =  value;
		nElem++;
	}
	public void display(){
		for (int i = 0; i < nElem; i++) {
			System.out.print(theArray[i]+"  ");
		}
		System.out.println(" ");
	}
	public void quickSort(){
		reQuickSort(0,nElem-1);
	}
	public void reQuickSort(int left,int right){
		if(right - left < 0){
			return;
		}
		int pivot = (left + right)/2;
		int partition = partitionIt(left,right,pivot);
		reQuickSort(left, partition-1);
		reQuickSort(partition+1, right);
	}
	/**
	 * @param leftPtr	左边起始下标
	 * @param rightPtr	右边起始下标
	 * @param pivot		中间数的下标
	 * @return			中间数的下标
	 */
	public int  partitionIt(int leftPtr,int rightPtr,int pivot){
		int temp = theArray[pivot];			//得到中间数
		theArray[pivot] = theArray[rightPtr];	//将最右边的数赋值给 中间变量
		while (leftPtr!=rightPtr) {
			//用最左边的数与中间数比较，若theArray[leftPtr] < temp, 则使leftPtr 递增，继续循环
			//直到 theArray[leftPtr] < temp 不满足条件为止，则退出循环
			while (leftPtr < rightPtr && theArray[leftPtr] < temp) {	
				leftPtr++;											
			}
			if(leftPtr < rightPtr){							//若左边数的下标 小于 右边数的下标 
				theArray[rightPtr] = theArray[leftPtr];		//将 以leftPtr 为下标的值赋给 以rightPtr 为下标的值 
				rightPtr--;									// rightPtr递减
			}
			//用递减后的 以rightPtr为下标的值 与temp 比较，若 theArray[rightPtr] > temp 则是rightPtr的值递减,继续循环
			//直到 theArray[rightPtr] > temp 不满足条件为止，退出循环
			while (leftPtr < rightPtr && theArray[rightPtr] > temp) {	
				rightPtr--;
			}
			if (leftPtr < rightPtr) {
				theArray[leftPtr] = theArray[rightPtr];		//将 以rightPtr 为下表的值赋给 以leftPtr 为下表的值
				leftPtr++;									//	leftPtr递增
			}			
		}
		theArray[leftPtr] = temp;
		return leftPtr;
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyQuickSort myQuickSort; //=  new MyQuickSort(5);
		int maxSize = 15;
		myQuickSort = new MyQuickSort(maxSize);
//		myQuickSort.insert(1);
//		myQuickSort.insert(5);
//		myQuickSort.insert(4);
//		myQuickSort.insert(3);
//		myQuickSort.insert(6);
		for (int i = 0; i < maxSize; i++) {
			int n = (int)(Math.random()*99);
			myQuickSort.insert(n);
		}		
		myQuickSort.display();
		myQuickSort.quickSort();
		myQuickSort.display();
	}

}

希尔排序法：

package com.test;

/**
 * @author Tiankj
 * 希尔排序法
 * 希尔排序法的原理：数据项移动的个数虽少，可是移动的距离很大，这样可以提高排序的效率。
 * H 越大，移动的数据项越少，H 越小，移动的数据项越多;
 * H减小的时候移动的数据项增多，但此时数据项已接近他们排序后最终的位置，这对于插入排序更有效。
 */
public class ShellSort {
	
	private int[] theArry;
	private int nElems;
	public ShellSort(int max){
		theArry = new int[max];
		nElems = 0;
	}
	public void insert(int value){
		theArry[nElems] = value;
		nElems++;
	}
	public void display(){
		System.out.print("A=");
		for (int i = 0; i < nElems; i++) {
			System.out.print(theArry[i]+" ");
		}
		System.out.println("");
	}
	public void shellSort(){
		int inner,outer;
		int temp;
		int h = 1;
		while(h<nElems/3){
			h = h*3+1;
		}
		while(h>0){
			for (outer = h; outer < nElems; outer++) {
				temp = theArry[outer];
				inner = outer;
				while (inner>h-1 && theArry[inner-h]>=temp) {
					theArry[inner] = theArry[inner-h];  //将相差 h 项的数据调换位置
					inner -= h;				//inner = inner - h
				}
				theArry[inner] = temp;		//将 以 outer 为下标的数据项 与 以相差 h 的数据调换位置
			}
			h = (h-1)/3;
		}
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int size = 10;
		ShellSort shell;
		shell = new ShellSort(size);
		for(int i = 0; i < size; i++ ){
			int n = (int)(Math.random()*99);
			shell.insert(n);
		}
		shell.display();
		shell.shellSort();
		shell.display();
	}

}

选择排序法：

package com.test;

/*
 * 选择排序法
 * 
 **/
public class SelectionSort {
	
	/*
	 * 选择排序的基本思想是每次从待排数据中选择第n小的数据放到排序列表的第n个位置，假如共有N个数据待排，那么经过N-1次排序后，待排数据就已经按照从小到大的顺序排列了。

　　直接选择排序算法的思想比较简单：（假设数据放在一个数组a中，且数组的长度是N）

　　1：从a[0]-a[N-1]中选出最小的数据，然后与a[0]交换位置

　　2：从a[1]-a[N-1]中选出最小的数据，然后与a[1]交换位置（第1步结束后a[0]就是N个数的最小值）

　　3：从a[2]-a[N-1]中选出最小的数据，然后与a[2]交换位置（第2步结束后a[1]就是N-1个数的最小值）

　　以此类推，N-1次排序后，待排数据就已经按照从小到大的顺序排列了。
	 * 
	 * */
	public static int[] a={140,1,15,5,17,23,20,98,45,110,120,100};
	public static void main(String[] args) {
		
		 for(int  i= 0; i <= a.length-1; i++){ 
	            int min = i; 			//给min依次赋值为0,1,2,...,10
	          //进行了N-1次比较，但是只进行了一次交换
	            for(int j = i; j <= a.length-1; j++){          //j=0
	            	
	                if(a[min] > a[j]){ 		//比较出最小的  j=1  若a[0]>a[1]	
	                	min = j; 			//则a[0]=a[1],即将较小者放在数组的首位	                	
	                } 
	            } 
	            if(min != i){//交换元素 
	                int temp = a[i]; 
	                a[i] = a[min]; 
	                a[min] = temp; 
	            } 
	            
	        } 
		
		 for (int k = 0; k < a.length; k++) {
				System.out.println(a[k]);
		}
	}
}

归并排序法：

package com.test;



public class DArray {
	public int[] theArray;
	public int nElems;
	public DArray(int max){
		theArray = new int[max];
		nElems = 0;
	}
	public void insert(int value){
		theArray[nElems] = value;
		nElems++;
	}
	public void mergeSort(){
		int[] workSpace = new int[nElems];
		recMergeSort(workSpace, 0, nElems-1);
	}
	public void recMergeSort(int[] workSpace,int begin,int end){
		if(begin == end){
			return;
		}else{
			int mid = (begin+end)/2;
			recMergeSort(workSpace, begin, mid);
			recMergeSort(workSpace, mid+1, end);
			merge(workSpace, begin,mid+1, end);
		}
		
	}
	/**
	 * @author Administrator
	 * @param workSpace   空数组
	 * @param lowPtr	 数组开始的下标
	 * @param highPtr	 数组(begin+end)/2+1 的下标
	 * @param upper		数组结束的下标
	 */
	public void merge(int[] workSpace,int lowPtr,int highPtr,int upper){
		int j = 0;
		int lower = lowPtr;				//开始下标,每次递归都在增加
		int mid = highPtr - 1;			//中间下标
		int n = upper-lower+1;			
		while(lowPtr <= mid && highPtr <= upper){
			if(theArray[lowPtr] < theArray[highPtr]){  //将两个数组的第一个进行比较
				workSpace[j++] = theArray[lowPtr++];
			}else { 
				workSpace[j++] = theArray[highPtr++];
			}
		}
		while (lowPtr <= mid) {			//把lowPtr 到 mid 部分剩余的往workSpace里面复制
			workSpace[j++] = theArray[lowPtr++];
		}
		while (highPtr <= upper) {		//把highPtr 到 upper 部分剩余的往workSpace里面复制
			workSpace[j++] = theArray[highPtr++];
		}
		for (j = 0; j < n; j++) {		//每次递归，都将两个数组合并成一个
			theArray[lower+j] = workSpace[j];
			System.out.println(workSpace[j]+"  "+"j="+j+"  n="+n);
		}
	}
	public void display(){
		for (int i = 0; i < nElems; i++) {
			System.out.print(theArray[i]+" ");
		}
	}
	public static void main(String[] args) {
		int maxSize = 8;
		DArray array;
		array = new DArray(maxSize);
		array.insert(3);
		array.insert(1);
		array.insert(7);				
		array.insert(5);		
		array.insert(4);
		array.insert(3);
		
		array.display();
		
		array.mergeSort();
		
		array.display();
	}
}