快速排序源码

快速排序源码

 

import java.util.Date;
import java.util.Random;
/**
 * 
 * 
Description: 快速排序算法
 */
public class QuickSort{
	public static Random random = new Random();
	/**
	 * 
	 * 
Discription:快速排序算法
	 * @param a
	 * @param low
	 * @param high
	 */
	public static void quickSort(int[] a, int low, int high){
		if(low < high){
			int key = a[low];//选择一个为元素为主元
			int l = low;//低位索引
			int h = high;//高位索引
			while(l= key && l < h) h--;//从高位找小于主元的数
				if(l < h){//如果找到了
					a[l] = a[h];
					l++;
				}
				while(a[l] <= key && l < h) l++;//从低位找大于主元的数
				if(l < h){//如果找到了
					a[h] = a[l];
					h--;
				}
			}
			a[l] = key;//调整主元的位置
			quickSort(a, low, l-1);//对左边进行快速排序
			quickSort(a, l+1, high);//对右边进行快速排序
		}
	}
	
	/**
	 * 
	 * 
Discription:随机快速排序算法
	 * @param a
	 * @param low
	 * @param high
	 */
	public static void randomQuickSort(int[] a, int low, int high){
		if(low < high){
			int keyIndex = getRandomIndex(low, high);//随机选择一个为元素为主元
			swap(a, low, keyIndex);//主元与一个元素位置互换
			int key = a[low];//获得主元
			int l = low;//低位索引
			int h = high;//高位索引
			while(l= key && l < h) h--;//从高位找小于主元的数
				if(l < h){//如果找到了
					a[l] = a[h];
					l++;
				}
				while(a[l] <= key && l < h) l++;//从低位找大于主元的数
				if(l < h){//如果找到了
					a[h] = a[l];
					h--;
				}
			}
			a[l] = key;//调整主元的位置
			randomQuickSort(a, low, l-1);//对左边进行快速排序
			randomQuickSort(a, l+1, high);//对右边进行快速排序
		}
	}
	
	/**
	 * 
	 * 
Discription:优化的随机快速排序算法（单要排序的个数较少时，使用冒泡排序）
	 * @param a
	 * @param low
	 * @param high
	 */
	public static void optimizedRandomQuickSort(int[] a, int low, int high){
		if(low < high){
			//单要排序的个数较少时，使用冒泡排序
			if(high - low < 4000){
				bubbingSort(a, low, high);
			}else{
				//单要排序的个数较大时，使用随机快速排序
				int keyIndex = getRandomIndex(low, high);//随机选择一个为元素为主元
				swap(a, low, keyIndex);//主元与一个元素位置互换
				int key = a[low];//获得主元
				int l = low;//低位索引
				int h = high;//高位索引
				while(l= key && l < h) h--;//从高位找小于主元的数
					if(l < h){//如果找到了
						a[l] = a[h];
						l++;
					}
					while(a[l] <= key && l < h) l++;//从低位找大于主元的数
					if(l < h){//如果找到了
						a[h] = a[l];
						h--;
					}
				}
				a[l] = key;//调整主元的位置
				optimizedRandomQuickSort(a, low, l-1);//对左边进行快速排序
				optimizedRandomQuickSort(a, l+1, high);//对右边进行快速排序
			}
		}
	}
	/**
	 * 
	 * 
Discription:冒泡排序
	 * @param a
	 * @param low
	 * @param high
	 */
	public static void bubbingSort(int[] a, int low, int high){
		int length = high - low + 1;
		boolean flag = true;//如果一趟发生移位，设false,如何没有移位说明已经排好序
		for(int i = 0; i< length -1; i++){
			flag = true;
			for(int j = 0; j < length - i -1; j++){
				if(a[j] > a[j+1]){
					swap(a, j, j+1);
					flag = false;
				}
			}
			if(flag == true){
				break;
			}
		}
	}
	/**
	 * 
	 * 
Discription:交换
	 * @param a
	 * @param index1
	 * @param index2
	 */
	public static void swap(int[] a, int index1, int index2){
		int temp = a[index1];
		a[index1] = a[index2];
		a[index2] = temp;
	}
	/**
	 * 
	 * 
Discription:获得随机位置
	 * @param low
	 * @param high
	 * @return
	 */
	public static int getRandomIndex(int low, int high){
		int length = high - low + 1;
		int newIndex = low + random.nextInt(length-1);//(int)Math.round(Math.random()*(length-1));
		return newIndex;
	}
	

	public static void main(String[] args){		
		int len = 15000000;
		int[] a = new int[len];
		
		//产生随机数
		Random random = new Random(System.currentTimeMillis());
		
		for(int i = 0; i < len; i++){
			a[i] = random.nextInt(100000000);
		}
		//普通快速排序
		long beginTime = new Date().getTime();
		QuickSort.quickSort(a, 0, a.length-1);
		long endTime = new Date().getTime();
		long time = (endTime - beginTime);
		System.out.println("general quick sort used  " + time + " ms");
		
		//产生随机数
		for(int i = 0; i < len; i++){
			a[i] = random.nextInt(100000000);
		}
		
		//随机快速排序
		beginTime = new Date().getTime();
		QuickSort.randomQuickSort(a, 0, a.length-1);
		endTime = new Date().getTime();
		time = (endTime - beginTime);
		System.out.println("random quick sort used " + time + " ms");
		
		//产生随机数
		for(int i = 0; i < len; i++){
			a[i] = random.nextInt(100000000);
		}
		
		//优化的随机快速排序
		beginTime = new Date().getTime();
		QuickSort.optimizedRandomQuickSort(a, 0, a.length-1);
		endTime = new Date().getTime();
		time = (endTime - beginTime);
		System.out.println("optimized random quick sort used " + time + " ms");
				
	}
}