交换排序的实现——快速排序

快速排序

基本思想：从待排序的数组中任取一个数据作为分界值，所有比其小的数据元素一律放到左边，所有比其大的元素一律放到右边。经过一趟遍历，该数组形成左右两个子序列，左边序列中数据元素的值都比分界值小，右边序列中的数据元素值都比分界值大。(分界值的选取是关键点，简单起见，一般都是选择一个值)。

然后对左右两个子数组进行递归，对两个子序列重新选择分界值并以此进行调整，知道每个子数组只有一个元素。

算法实现：

package my.sort;

public class QuickSort {
	//交换数值
	private static void swap(int[] datas, int i, int j) {
		int temp = datas[i];
		datas[i] = datas[j];
		datas[j] = temp;
	}

	private static void subSort(int[] datas, int start, int end) {
		if (start < end) {
			int base = datas[start];
			int i = start;
			int j = end + 1;

			//遍历找过索引值
			while (true) {
				while (i < end && datas[++i] <= base);
				while (j > start && datas[--j] >= base);
				
				if(i<j){
					swap(datas,i,j);
				}else{
					break;
				}
			}
			
			swap(datas,start,j);
			
			//递归
			subSort(datas,start,j-1);
			subSort(datas,j+1,end);
		}
	}

	public static void quickSort(int[] datas) {
		subSort(datas,0,datas.length-1);
	}
	
	public static void main(String[] args){
		int[] array = { 22, 30, 49, 30, 16, 9 };
		QuickSort.quickSort(array);
		System.out.println(java.util.Arrays.toString(array));
	}
}

算法时间复杂度：最好O(nlogn)，最坏O(n*n)，平均：O(nlogn)
空间复杂度：O(log2n)
稳定性：不稳定