手撸快速排序 -- java 排序算法之快速排序(左右指针法)

基本思路：

1．将数组的第一作为基准数 stone 。
2．以 stone 进行分组，左边要小于或等于 stone ; 右边大于或等于 stone ; 

例：[12, 21, 3, 5, 2, 18]  以 12 为 stone  low = 0 ; hi = array.length-1;

分组过程:

记录　stone  index

int oldIndex = low;　

hi 开始向前找比 stone 大的的数（hi 找大最后大的全移右边），循环找 比 low< hi，由右向左找  stone 值 和rray[hi]比较，找不到hi- -找到,退出循环；

while(low<hi&&rray[hi] >= stone)

{

    hi--

}

从数组的首元素 low 开始向后找比 stone 的数（low 找小，小的最后全移左边），循环找low <hi，由左向右，low++ 找到,退出循环；

while(low<hi&&rray[low] <= stone)

{

    low++

}

找到后然后两者交换（swap）,

if(low<hi)

{

    array[low],arry[hi],交换

}

再循环，直到 low<hi终止；最后判断，if(low==hi)  移 stone 到正确位置，完成分组，以stone 划分 左边小，右边大；

if(low==hi)

{

   array[oldInde ], array[low] 交换

}

记下当前 divideIndex ;
3．再对左组小值组,递归 hi = divideIndex -1; 右值组 递归 low = divideIndex +1，直到各区间只有一个数。

快速排序之左右指针排序前:[12, 21, 3, 5, 2, 18]
left ,right swap low:1 hi:4 array:[12, 2, 3, 5, 21, 18]
stone Index :0 divideIndex:3 move stone swap :[5, 2, 3, 12, 21, 18]
stone Index :0 divideIndex:2 move stone swap :[3, 2, 5, 12, 21, 18]
stone Index :0 divideIndex:1 move stone swap :[2, 3, 5, 12, 21, 18]
stone Index :4 divideIndex:5 move stone swap :[2, 3, 5, 12, 18, 21]
快速排序之左右指针排序后:[2, 3, 5, 12, 18, 21]

 

import java.util.Arrays;

/**
 * 第次以 array[low ] 为 stone 划分两部分，最后记得把 stone 放到中间位置；递归，最后可得到结果；
 * 
 * @author jacli
 * 
 */

public class quickSort {

	public static void swap(int[] array, int low, int hi) {
		int tmp = array[low];
		array[low] = array[hi];
		array[hi] = tmp;
	}

	public static int getDivideIndex(int[] array, int low, int hi) {
		int stoneValue = array[low];
		// save stone index 最后记得把 stone 放到中间位置
		int oldStoneIndex = low;
		while (low < hi) {
			// first hi

			// hi 从右向左移，如果 值小于 stone hi ++ ；如果大于去和左边low互换，小值 最后全跑左边
			while (low < hi && array[hi] >= stoneValue) {
				hi--;
			}

			// low 从左向右移，如果 值小于 stone hi ++ ；如果大于去和左边low互换，小值 最后全跑左边
			while (low < hi && array[low] <= stoneValue) {
				low++;
			}
			// 互换 low,hi 值，小值跑左边，大值跑右边；
			if (low < hi) {
				swap(array, low, hi);
				System.out.println("left ,right swap low:" + low + " hi:" + hi
						+ " array:" + Arrays.toString(array));
			}
		}
		// 最后把 stone 移到相应位置
		if (low == hi) {
			swap(array, oldStoneIndex, hi);
			System.out.println("stone Index :" + oldStoneIndex
					+ " divideIndex:" + hi+ " move stone swap :"
					+ Arrays.toString(array));
		}

		return low;
	}

	public static void quickSort(int[] array, int low, int hi) {
		if (low < hi) {
			// array[low] get divideIndex divice two part;
			int divideIndex = getDivideIndex(array, low, hi);
			// 由 stone 分两部分，左边小值，右边大值
			// 继续递归
			quickSort(array, low, divideIndex - 1);
			quickSort(array, divideIndex + 1, hi);

		}
	}

	public static void main(String[] args) {

		int[] arrays = { 12, 21, 3, 5, 2, 18 };

		System.out.println("快速排序之左右指针排序前:" + Arrays.toString(arrays));
		quickSort(arrays, 0, arrays.length - 1);
		System.out.println("快速排序之左右指针排序后:" + Arrays.toString(arrays));
	}

}