快速排序

快速排序利用 分治的思想：

1.分解：数组A[p....r] 分为 A[p....q -1] 和A[q + 1....r](可能有空的)，使得前者的每一个元素都小于A[q]，后者的每一个元素都大于A[q]。

2.解决：递归使用快速排序，对子数组A [p....q -1] 和A[q + 1....r]进行排序。

3.合并：因为是原址排序，愿意无需合并，A[p....r]已经有序。

参考代码：

public class QuickSort {

	public static void main(String[] args) {
		int [] a= {2, 8, 7, 1, 3, 5, 6, 4};
		quickSort(a, 0, a.length - 1);
		System.out.println(Arrays.toString(a));
	}
	private static void quickSort(int[] a, int start, int end) {
		if(start < end){
			int q = partition(a, start, end);
			quickSort(a, start, q - 1);
			quickSort(a, q + 1, end);
		}	
	}
	private static int partition(int[] a, int p, int r) {
		int x = a[r];
		int i = p - 1;
		for(int j = p; j <= r - 1; j ++){//要注意是<=
			if(a[j] <= x){
				i = i + 1;	
				swap(a, i, j);
			}
			
		}
		swap(a, i + 1, r);
		return i + 1;
	}
	
	private static void swap(int [] a, int i, int j) {
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}	
}

patition过程分析：

上面的表示下标，以最后一个为参考值，i = - 1, j 从0开始

0	1	2	3	4	5	6	7
2	8	7	1	3	5	6	4

A[0]就满足，所以调换，但是此时i + 1 = 0,所以继续往后，直到A[3]这一处，此时i + 1 = 1,所以结果是：

0	1	2	3	4	5	6	7
2	1	7	8	3	5	6	4

继续找，A[4]也满足if判断要求，此时i + 1 = 2,结果是：

0	1	2	3	4	5	6	7
2	1	3	8	7	5	6	4

后面的都不满足判断条件，然后交换i + 1 = 3处和r= 7处的值。结果是：

0	1	2	3	4	5	6	7
2	1	3	4	7	5	6	8

那选取其他位置作为这个参考值行么？也是可以的，只要保证他之前的小于等于它， 后面的大于等于它。

故而在使用了一个随机化的版本，即通过产生随机数的形式。参考代码：

private static int randomPartition(int[] a, int left, int right) {
	Random random = new Random();
	int i = random.nextInt(right - left) + left;
	swap(a, right, i);
	return partition(a, left, right);
	}

结果截图：

参考： 《算法导论》

以上就是这篇的内容了，如果您有什么觉得改进的地方或者发现了错误的部分，请指出。谢谢！