1.介绍

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一 部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序 过程可以递归进行，以此达到整个数据变成有序序列。

快速排序最好时间复杂度是O(n * log n),最坏时间复杂度是O(n*2) ，平均复杂度是O(n * log n) 

对数log n :表示以2为底 n的对数

2.切分原理 

切分原理： 把一个数组切分成两个子数组的基本思想：

1.找一个基准值，用两个指针分别指向数组的头部和尾部；

2.先从尾部向头部开始搜索一个比基准值小或等于的元素，搜索到即停止，并记录指针的位置；

3.再从头部向尾部开始搜索一个比基准值大或等于的元素，搜索到即停止，并记录指针的位置；

4.交换当前左边指针位置和右边指针位置的元素；

5.重复2,3,4步骤，直到左边指针的值大于右边指针的值停止。 

代码实现

import java.time.Duration;
import java.time.LocalTime;

public class QuickSort {

	public static void main(String[] args) {
		test1();
//		test2();
	}
	
	
	public static void test1() {
//		int arr[]= {-9,78,0,23,-567,70};
		int len = 12;
		int arr[]=new int [len];
		for(int i=0;i<len;i++) {
			arr[i]=(int) (Math.random()*100);
		}
		System.out.println("排序前的数组：");
		printArr(arr);
		quickSort(arr, 0, arr.length-1);
		System.out.println("排序后的数组：");
		printArr(arr);
	}
	
	
	//若干万数据，测试排序的时间
	public static void test2() {
		int len=80000;
		int arr[]=new int [len];
		
		for(int i=0;i<len;i++) {
			arr[i]=(int) (Math.random()*len);
		}
		
		LocalTime before=LocalTime.now();
		System.out.println("排序前的时间："+before);
		quickSort(arr,0,len-1);
		LocalTime after=LocalTime.now();
		Duration duration=Duration.between(before, after);
		System.out.println("排序后的时间："+after);
		System.out.println("时间差(毫秒)："+duration.toMillis());
	}
	
	private static void quickSort(int[] arr, int lo, int hi) {
		if(lo>=hi) return ;
		int partition=partition(arr,lo,hi);
		quickSort(arr,lo,partition-1);
		quickSort(arr,partition+1,hi);
	}


	private static int partition(int[] arr, int lo, int hi) {
		//把最左边的元素当作基准值
		int key=arr[lo];
		int left=lo; //
		int right=hi+1;
		while(true) {
			//左指针遇到>=key的值，才停下
			while(arr[++left] < key) {
				if(left==hi) break;
			}
			
			//右指针遇到<=key的值，才停下
			while(key < arr[--right]) {
				if(right==lo) break;
			}
			
			
			
			if(left>=right) {
				//扫描了所有元素，结束循环
				break;
			}else {
				//交换左右指针
				swap(arr,left,right);
			}
		}
		//right指向的值一定是小于或等于key值，所以交换key和右指针的值
		swap(arr,lo,right);
		return right;
	}


	/**
	 * 交换数组两个元素
	 * @param arr
	 * @param i
	 * @param j
	 */
	private static void swap(int[] arr, int i, int j) {
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}


	private static void printArr(int[] arr) {
        for (int i : arr) {
            System.out.print(i+" ");
        }
        System.out.println();
    }
}

运行结果：

test1()

 test2

快速排序的另一种实现

我认为这种写法更容易理解

public static void QuickSort(int []arr,int low,int high) {
		if(low<high) {
			int pivotpos=partition(arr,low,high);
			QuickSort(arr,low,pivotpos-1);
			QuickSort(arr,pivotpos+1,high);
		}
	}

	private static int partition(int[] arr, int low, int high) {
		 int pivot=arr[low];
		 while(low<high) {
			 //起初，一定要从右边指针开始，因为arr[low]的值已经扔给了pivot，arr[low]
			 //想象成无数字的空位
			 while(low<high&&pivot<=arr[high]) {
				 --high;
			 }
			 
			 //把比pivot的小的数扔到左边指针
			 //把arr[high]扔到arr[low]这个空位上
			 //然后，high位置可以想象成无数字的空位
			 arr[low]=arr[high];
			 
			 while(low<high&&arr[low]<=pivot) {
				 ++low;
			 }
			 //把比pivot大的数扔到右边
			//把arr[low]扔到arr[high]这个空位上
			//然后，low位置可以想象成是无数字的空位
			 arr[high]=arr[low];
		 }
		 //此时low==high,return high也一样
		 arr[low]=pivot;
		return low;
	}
}