快速排序

快排也是用到了分治法的思想，对一个子数组A[p...r]排序的分治过程为三个步骤：

1.分解：

A[p..r]被划分为俩个（可能空）的子数组A[p ..q-1]和A[q+1 ..r]，使得

A[p ..q-1] <= A[q] <= A[q+1 ..r]

2.解决：通过递归调用快速排序，对子数组A[p ..q-1]和A[q+1 ..r]排序。
3.合并。

java实现：

public int[] quickSort(int[] arrays) {
if (null == arrays || arrays.length == 0) {
return arrays;
}
quickSort(arrays, 0, arrays.length -1);
return arrays;
}

public void quickSort(int[] arrays, int begin, int end) {
if (begin == end) {
return;
}
if (begin < end) {
int mid = partition(arrays, begin, end);
quickSort(arrays, begin, mid - 1);
quickSort(arrays, mid + 1, end);
}
}

/**
* 
* PARTITION(arrays, begin, end) 
* 1.key ← arrays[end] 
* 2. i ← begin - 1 
* 3. for j ← begin to end - 1 
* 4. do if
* arrays[j] ≤ key 
* 5. then i ← i + 1 
* 6. exchange arrays[i] <-> arrays[j] 
* 7. exchange arrays[i + 1]<-> arrays[end] 
* 8. return i + 1
*/
private int partition(int[] arrays, int begin, int end) {
int key = arrays[end];
int i = begin - 1;
for(int j = begin; j < end; j++){
if(arrays[j] < key ) {
i++;
swap(arrays,i,j);
}
}
swap(arrays,i+1,end);
return i+1;
}

private void swap(int[] arrays, int i, int j) {
int tmp = arrays[j];
arrays[j] = arrays[i];
arrays[i] = tmp;
}

public static void main(String[] args) {
int[] arrays = { 10, 5, 4, 8, 74, 58, 12, 14, 14, 56, 3, 1, 11, 57, 41,
102, 13,256 };
arrays = new QuickSort().quickSort(arrays);
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]);
System.out.print(",");
}
}

}