Java算法之经典快速排序和随机快速排序

经典快排代码： 

package cn.itcats.sort;

import org.junit.Test;

/**
 * (<R  =R  >R)归类快速排序,每次取数组最后一个数进行比较归类
 * @author fatah
 */
public class QuickSort {
	public void quickSort(int arr[]) {
		if(arr ==null && arr.length < 2) {
			return;
		}
		quickSort(arr,0,arr.length-1);
	}

	public void quickSort(int[] arr, int L, int R) {
		if(L < R) {
			int [] p = partition(arr,L,R);
			quickSort(arr, L, p[0]-1);
			quickSort(arr,p [1] +1,R);
		}
	}

	public int[] partition(int[] arr, int L, int R) {
		int less = L -1;
		int more = R;
		while(L < more) {
			if(arr[L] < arr[R]) {
				swap(arr,++less,L++);
			}
			else if(arr[L] >arr[R]) {
				swap(arr,--more,L);
			}else {
				L++;
			}
		}
		//交换最后一个数字,把最后比较的x值和more的第一个位置(被排好序的x)放到一起
		//小于x  =x  大于x
		swap(arr,more,R);
		return new int [] {less +1 ,more};
	}

	private void swap(int[] arr, int i, int j) {
		int temp = arr[j];
		arr[j] = arr[i];
		arr[i] = temp;
	}
	
	@Test
	public void flagTest() {
		int num = 5;
		int[] arr = { 4, 5, 3, 7, 6, 8, 0, 5 };
		quickSort(arr, 0, arr.length - 1);
		for (int i : arr) {
			System.out.print(i + "  ");
		}
	}
}

经典快排 时间复杂度O(N²)，每次排序只解决一个数字的排序。(小于区域和大于区域规模不均)，和数据状况有关系。

如数组arr为{1,2,3,4,5,6}，使用最后一个数6进行划分，此时只有<6的区域和等于6的区域，partition一遍后，只搞定一个数6，代价为O(N)，接下来又使用5去比较划分，也只搞定了一个数5...一共有N个数，每个数都需要O(N)，则总共为O(N²)。

使用随机快速排序和经典快排不同，经典快排序每次取数组最后一个数进行比较归类，而随机快排是每次从数组中随机取一个数，放在数组末尾索引，进行排序，后续步骤同经典快排，只是取值比较的值是随机取的，那么无论最好还是最坏情况它都是一个概率事件，在大样本环境下，经过概率学证明后可以得到随机快排时间复杂度可以达到O(N*logN)。

 

随机快排代码：

package cn.itcats.sort;

import org.junit.Test;

public class RandomQuickSort {
	public void RandomQuickSort(int [] arr) {
		if(arr == null && arr.length <2) {
			return ;
		}
		RandomQuickSort(arr,0,arr.length-1);
	}

	public void RandomQuickSort(int[] arr, int L, int R) {
		if(L<R) {
			int [] part = partition(arr,L,R);
			RandomQuickSort(arr,L,part[0]-1);
			RandomQuickSort(arr,part[1]+1,R);
		}
	}

	private int[] partition(int[] arr, int L, int R) {
		int less = L - 1;
		//只加了这么一句代码。指在L ~ R范围内产生一个随机数
		int ranR = L + (int)(Math.random() * (R-L+1));
		//把随机数作为索引,将索引对应值与最后一位值 R 交换
		swap(arr,ranR,R);
		int more = R;
		while(L < more) {
			if(arr[L] < arr[R]) {
				swap(arr,++less,L++);
			}else if(arr[L] > arr[R]) {
				swap(arr,--more,L);
			}else {
				L++;
			}
		}
		swap(arr,R,more);
		return  new int[] {less+1,more};
	}

	public void swap(int[] arr, int L, int R) {
		int temp = arr[L];
		arr[L] = arr[R];
		arr[R] = temp;
	}
	
	@Test
	public void flagTest() {
		int num = 5;
		int[] arr = { 4, 5, 3, 7, 6, 8, 0, 5 };
		RandomQuickSort(arr);
		for (int i : arr) {
			System.out.print(i + "  ");
		}
	}
}

经典快速排序过渡到随机快速排序，时间复杂度由O(N²)下降到了O(N * logN)。其实在算法里面，规避样本量对时间复杂度的影响有两种做法，除了产生随机数的方式外，还可以使用hash。

随机快速排序时间复杂度O(N*logN)，额外空间复杂度O(logN)，大样本期望的额外空间复杂度是O(logN)，最差情况的额外空间复杂度是O(N)

补充：为什么随机快排额外空间复杂度为O(logN)呢？

如int []  arr = {0,1,2,3,4,5,6,7}，我们需要使用partition记录断点位置，断点如果都打在中间，则8条数据只需要记录3次断点即可，这为最好情况，但如果断点打在7，第二次打在6，第三次打在5...则8条数据，一共需要记录8次断点，这就为最差情况。