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);
		}
	}
	

}