java 递归实现快速排序

快速排序 之所以快，是因为采用分治的策略，将排序细分化，这样下来，整个快速排序的时间复杂度为O(N*logN) , 比那些常规的冒泡排序，选择排序，都要快。但是这里存在了一个弊端，就是如果目标数组是一个很大的数组，由于递归的原因，可能会引发栈内存溢出的问题。个人认为如果单从递归实现的快速排序来说，它适合于那种数组相对较大（例如大于20个输入规模），且要求效率的情况下使用。

package quicksort;

public class quickSortTest {

/**
* @param args
*/
public static void main(String[] args) {
int[] src = {7, 9, 2, 3, 6, 5, 4, 1, 8, 10};
quickSort(src);

for (int i : src) {
System.out.print(" " + i);
}
}

/**
* 对整个源数组进行快速排序
* @param src
* @return
*/
public static void quickSort(int[] src) {
sortPartision(src, 0, src.length - 1);
}

/**
* 排序分治区域
* @param src
* @param start
* @param end
*/
private static void sortPartision(int[] src, int start, int end) {
int l = start;
int r = end;
int x = src[l];
while (l < r) {
while (l < r && src[r] > x) {
r--;
}
if (src[r] < x) {
src[l] = src[r];
l++;
}
while (l < r && src[l] < x) {
l++;
}
if (src[l] > x) {
src[r] = src[l];
r--;
}
}

src[l] = x;

int i = l;
if (i > start) {
sortPartision(src, start, i-1);
}
if (i < end) {
sortPartision(src, i+1, end);
}
}

}