升级版快速排序算法

前面给大家讲过了经典快速排序算法，今天给大家介绍的是升级版的快速排序算法。具体的算法思想如下：将数列递归划分成最小区和最大区，然后中间放置的是相等数，然后利用递归思想不断划

package alrithmetic;

import java.util.Arrays;

public class QuickSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		设置参数
		int maxsize=10;
		int maxvalue=100;
		int maxtime=100000;
		boolean success=true;
//		开始测试
		for (int i = 0; i < maxtime; i++) {
			int[] arr1=gengerarray(maxsize, maxvalue);
			int[] arr2=copyarr(arr1);
//			开始测试两个排序函数
			sort(arr1);
			comparator(arr2);
//			比较测试结果，只要有一次不一样，就退出测试
			if (!isequal(arr1, arr2)) {
				success=false;
				return;
			}
		}
//		判断success的值为true or false
		System.out.println(success?"well done":"fucking fucked");
//		最后使用我们自定义的快速排序函数
		int[] arr=gengerarray(maxsize, maxvalue);
		printarray(arr);
		sort(arr);
		printarray(arr);
		
	}
//		排序函数入口
	public static void sort(int[] arr){
		if (arr == null || arr.length < 2) {
			return;
		}
		quicksort(arr, 0, arr.length-1);
	}
//		递归调用排序函数
	public static void quicksort(int[] arr,int left,int right){
		if (left<right) {
//			每次递归排序都随机从数列中选一个数与数列最右边的数交换位置，减少递归次数
			swap(arr, left+(int) (Math.random()*(right-left+1)), right);	
			int[] p=partition(arr, left, right);			//划分成左右两部分
			quicksort(arr, left, p[0]-1);					//左边递归划分
			quicksort(arr, p[1]+1, right);					//右边递归划分
		}
	}
//	快速排序算法核心函数
	public static int[] partition(int[] arr,int left,int right){
		int less=left-1;
		int more=right;
		while (left<more) {
			if (arr[left]<arr[right]) {
				swap(arr, ++less,left++ );
			}else if (arr[left]>arr[right]) {
				swap(arr, --more, left);
			}else {
				left++;
			}
		}
//		最后把一开始划入最大区的元素和最大区的边界元素交换位置
		swap(arr, more, right);
//		返回最小区和最大区的边边界下标
		return new int[]{less+1,more};
	}
//	交换函数
	public static void swap(int[] arr,int i,int j){
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}
//	打印数组函数
	public static void printarray(int[] arr){
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}
//	复制数组函数
	public static int[] copyarr(int[] arr){
		int[] arr1=new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			arr1[i]=arr[i];
		}
		return arr1;
	}
//	随机产生数组函数
	public static int[] gengerarray(int maxsize,int maxvalue){
		int[] arr=new int[(int) ((maxsize+1)*Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i]=(int)((maxvalue+1)*Math.random())-(int)(maxvalue*Math.random());
		}
		return arr;
	}
//	调用java自带的系统排序算法，用来做比较
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}
//	数组比较函数
	public static boolean isequal(int[] arr1,int[] arr2){
		if (arr1==null&&arr2!=null || arr1!=null&&arr2==null) {
			return false;
		}else if (arr1.length!=arr2.length) {
			return false;
		}else if (arr1==null&&arr2==null) {
			return false;
		}
		for (int i = 0; i < arr2.length; i++) {
			if (arr1[i]!=arr2[i]) {
				return false;
			}
		}
		return true;
	}
}

分最小区和最大区以达到数列的有序排列。