从简单问题出发推导出快排

最初想法来源于另外一个稍微简单的问题：将数组中的正数移动到左边，负数移动到右边。

	public static void main(String[] args) {
		int[] arr =  {8, 6, 4, -3, 5, -2, -1, 0, 1, -9, 1, -1};	
		for (int i = 0,j = 0; i < arr.length; i++) {
			if(arr[i]>=0) { //当前值大于等于0，自己与自己交换。或者当j指针指向负数时，与j指针对应的数交换
				int temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp; 
				j++; //大于等于0，指针继续走，遇到负数停下，等待下一个正数然后交换。
			}	
		}
		System.out.println(Arrays.toString(arr));
	}

那时得到了一种快慢指针交换方法去解决上面那个问题，之后通过思考发现可以上面问题升级为

：将数组中的大于某个数X的数移动到X的左边，小于X的数移动到X的右边。

    public static void main(String[] args) {
        int[] arr =  {-10, 3, 8, 6, 4, -3, 5, -2, -1, 0, 1, -9, 1, -1, 2};
        int j = 0;
        int low = arr[0];

        for (int i = 0; i < arr.length; i++) {
            if(arr[i] >= low) { 
                if(arr[i] != arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
                j++;
                System.out.println(Arrays.toString(arr));
            }
        }
        //作用是与最后一个下标j的数交换,保证下标j左边的数大于等于low,右边的数小于等于low
        if(j > 0){
            arr[0] = arr[j-1];
            arr[j-1] = low;
        }

        System.out.println(Arrays.toString(arr));
    }

此时已经很接近快排了，因为对上面的问题，在递归处理后可以使每个数对应到一个确凿的位置。

    public static void main(String[] args) {
        int[] arr =  {3, 8, 6, 4, -3, 5, -2, -1, 0, 1, -9, 1, -1, 2};
        quickSort(0,arr.length,arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void quickSort(int low, int high, Integer[] arr) {

        if(low >= high) {
            return;
        }

        int i = low,j = low;
        int lv = arr[low];

        while(i < high) {
            if(arr[i] <= lv) {
                swap(i, j, arr);
                j++;
            }
            i++;
        }

        arr[low] = arr[j-1];
        arr[j-1] = lv;

        quickSort(low,j - 1, arr);
        quickSort(j ,high, arr);
    }

这种方法恐怕早就有人想到了，这里写出来的目的就是让大家可以了解到快排的思路。