快速排序及其优化

1、快速排序的基本思想： 

快速排序使用分治的思想，通过一趟排序将待排序列分割成两部分，其中一部分记录的关键字均比另一部分记录的关键字小。之后分别对这两部分记录继续进行排序，以达到整个序列有序的目的。原始快排代码如下。

package suanfa;




import java.util.Arrays;
import java.util.Scanner;import java.util.concurrent.CountDownLatch;

public class Main {
	
	public static void main (String[] args) {
		int[] arr = {4,2,3,5,3};
		int[] arr1 = {1,2,3,4,5};
		quickSort(arr,0,arr.length-1);
		System.out.println(Arrays.toString(arr));
	}
	public static void  quickSort(int[] arr,int left,int right) {
		int temp ;
		if(left < right) {
			temp = partition (arr, left, right);
			quickSort(arr, left, temp-1);
			quickSort(arr, temp+1, right);
		}
	}
	public static int  partition(int[] arr,int left,int right) {
		int tem = arr[left];
		int i = left;
		int j = right;
		while(i!=j){
			while(i < j && arr[j]>= tem) {//右侧比tem小的值
				j--;
			}
			if(i<j) {
				arr[i] =arr[j];//将比tem小的值付给最左边，因为这步的赋值导致了快排的不稳定性
			}
			while (i<j && arr[i]<=tem) {//寻找比tem大的值
				i++;
			}
			if(i<j) {//将比tem大的值付给最右边的值，因为这步的赋值导致了快排的不稳定性
				arr[j] = arr[i];
			}
			
		}
		arr[i] = tem;
		return i;
		
		
	}
	public static void  swap(int[] arr, int i,int j) {
		arr[i] = arr[i]^arr[j];
		arr[j] = arr[i]^arr[j];
		arr[i] = arr[i]^arr[j];
	}
}

快排的取准的三种方式：固定取值，随机取准，三数取中；四种优化：

优化1：当待排序序列的长度分割到一定大小后，使用插入排序

优化2：在一次分割结束后，可以把与Key相等的元素聚在一起，继续下次分割时，不用再对与key相等元素分割

优化3：优化递归操作

优化4：使用并行或多线程处理子序列（略）

优化2的方法使用荷兰国旗问题进行优化，荷兰国旗问题即对于一组数中，选取一个数作为基准，比它大的排在后面，比它小的放前面，相等的放中间。这个优化主要减少了快排中一次只确定一个数而不能确定相的等的数的缺陷，比如

int[] arr = {3，4,2,,5,3};

原始快排取基准为右边的3的话，第一次排完结果为3，2，3，5，4，而使用优化过的排序结果是2，3，3，5，4；显然减少了一次相同数3 的排序时间。附上代码

public static void quickSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		quickSort(arr, 0, arr.length - 1);
	}

	public static void quickSort(int[] arr, int l, int r) {
		if (l < r) {
			swap(arr, l + (int) (Math.random() * (r - l + 1)), r);
			int[] p = partition(arr, l, r);
			quickSort(arr, l, p[0] - 1);
			quickSort(arr, p[1] + 1, r);
		}
	}

	public static 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++;
			}
		}
		swap(arr, more, r);
		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;
	}

此文参考 三种快排及四种优化方式