1.1算法思路——

该算法在数组中选定一个元素作为主元（一般选第一个），然后以这个主元为参考对象将数组分为两个部分，第一部分都是小于或者等于主元，第二部分都是大于或者等于主元。然后对第一和第二部分递归地使用快速排序算法，直到分到最小的小组为止。

1.2时间复杂度——

在最差的情况下，要把n个元素的数组划分，需要n次比较和n次移动。假设用T(n)来表示使用快速排序算法来排序n个元素的数组所耗费的时间。那么

 T（n） = T(n/2)+ T(n/2) +2n

所以，快速排序的时间复杂度应该是 T（n） =O(nlogn)。

1.3程序流程图

1.4实现代码

package lin.algo;

public class QuickSort {

	int[] list;
	public QuickSort(int[] list){
		this.list = list;
	}
	
	public int[] quickSort(){
		quick(list,0,list.length-1);
		return list;
	}
	
	private void quick(int[] list,int first , int last){
		if (last>first) {
			int pivoxIndex = partition(list, first, last);
			quick(list, first, pivoxIndex-1);
			quick(list, pivoxIndex+1, last);
		}
	}
	
	/**
	 * 根据第一个元素来划分数组
	 * 输入的是要划分的原始数组，第一个元素下标和最后一个元素下标
	 * @param list
	 * @param first
	 * @param last
	 * @return 分组后的主元下标
	 */

	private int partition(int[] list,int first , int last){
		//主元
		int privot = list[first];
		int secondIndex = first+1;
		int lastIndex = last;
		
		//遍历查询，大于主元的在右边，小于的在左边
		//实现方法：两边查起，将左边大于主元的与右边小于主元的交换，
		//最后把主元放在两个分好组的中间位置
		while(lastIndex>secondIndex){
			//寻找左边第一个比主元大的
			while(secondIndex<= lastIndex  &&list[secondIndex]<=privot ){
				secondIndex++;
			}
			
			//寻找右边第一个比主元小的
			while( secondIndex<= lastIndex  && list[lastIndex]> privot){
				lastIndex--;
			}
			
			//至此，如果还没检查完序列，就证明分别找到了，交换
			if (secondIndex< lastIndex) {
				int temp = list[secondIndex];
				list[secondIndex] = list[lastIndex];
				list[lastIndex] = temp;
			}
		}
		
		while(list[lastIndex] >= privot && lastIndex> first){
			lastIndex --;
		}
		
		//返回主元新下标
		if (privot > list[lastIndex]) {
			list[first] = list[lastIndex];
			list[lastIndex] = privot;
			return lastIndex;
		}else {
			return first;
		}
		
	}
}