图解：快速排序原理和java实现

基本思想

分而治之：意思就是将数据分成多块处理，最后将多块组合起来，大致步骤可描述成以下几步

1、将原始数据当成一块，先做一次排序处理

2、找出一把“刀”将数据切成2块

3、切出来的2块再分别做同样逻辑的排序

4、循环1-3步骤，不断将数据切分成N个小块，直到每个小块都有序，组合起来就全局有序了

示意图

步骤

1、左右坐标分别为L，R，基准值为 P=44，确定循环条件：L < R

2、R不断往左与P判断，过滤所有arr[R] > P的值，过滤一个，R坐标左移一次(R--)，遇到arr[R] < P，则交换arr[R] 与 P 的位置，然后L++

3、L不断往右与P判断，过滤所有arr[L] < P的值，过滤一个， L坐标右移一次(L++)， 遇到arr[L] > P， 则交换arr[L] 与 P 的位置， 然后R--

4、一直循环到 L == R 为一轮结束，返回L值，作为分治的划分点

5、用分治点划分出2个部分，分别再调用 1-4步骤计算，即递归调用

6、递归出口是 L >= R（初始状态是 L < R）

代码

public void beginQuickSort() {
	int[] arr = { 44, 2, 38, 5, 47, 15, 36, 26, 27, 3, 46, 4, 19, 50, 48, 15 };

	quitSort(arr, 0, arr.length - 1);
	System.out.println(Arrays.toString(arr));
}

public void quitSort(int[] arr, int startIndex, int endIndex) {
        // 【步骤6】递归出口
	if (startIndex >= endIndex)
		return;
	// 找出分治点
	int pIndex = sortImpl(arr, startIndex, endIndex);
	// 以分治点为分界，再递归调用本方法，【步骤5】
	quitSort(arr, startIndex, pIndex - 1);
	quitSort(arr, pIndex + 1, endIndex);
}

public int sortImpl(int[] arr, int index, int endIndex) {
        // 【步骤1】 确定基准值，左右坐标
        int _P = arr[index];
	int _L = index;
	int _R = endIndex;
        // 【步骤1】 确定循环条件
	while (_L < _R) {
		// 从右开始，过滤掉所有大于_P的值，【步骤2】
		while (_L < _R && arr[_R] > _P) {
			_R--;
		}
		if (arr[_R] < _P) {
			int temp = arr[_L];
			arr[_L] = arr[_R];
			arr[_R] = temp;
			_L++;
		}
		// 从左开始，过滤掉所有小于_P的值，【步骤3】
		while (_L < _R && arr[_L] <= _P) {
			_L++;
		}
		if (arr[_L] > _P) {
			int temp = arr[_L];
			arr[_L] = arr[_R];
			arr[_R] = temp;
			_R--;
		}
	}	
	return _L;
}