数据结构—快速排序

总览过程：
1. 在排序区间中选择一个基准值
2. 遍历整个待排序区间，将比基准值小的放在左边，大的放在右边
3. 分治思想（partition）
对左右的小区间分别用同样的方法处理，直到区间长度为1（有序）或0（没有数）

如何做partition？(参照数组，奇数在左，偶数在右的问题）
1.hoare // 两边往中间靠
2. 挖坑 // 两边往中间靠
3. Partition之前后下标 // 一边靠

注意：partition不是做快排，只是快排的一个步骤
partition一定要所有的数据都和基准值做过比较
（ 基准值在左，先走右边 ）

partition的时间复杂度：O(n)
空间复杂度：O(1)

快排的时间复杂度：O(n)O(二叉树的高度) O(nlog(n))~O(n^2)
空间复杂度： 二叉树的高度（递归产生调用栈） O(log(n))~O(n)

退化成单支树的两个因素：
1.数组的原顺序
2. 基准值的选择

修改选择基准值的办法：
3. 选择边上—原数组有序/逆序，就是单支树
4. 随机选择—不能消除单支树，但减少概率
5. 几数取中（三数取中）—消除单支树

快速排序的优化（了解内容）：
1. 因为处理少量数据效率不高（比插排慢）
Java中当待排序区间长度<=48,选择适用插排
2.当区间中和基准值相等的数较多

public class QuickSort{
private static void quickSortInter(int[] a,int left,int right){
if(left>=right){   //递归出口，长度<=1
return;
}
//选自基准a[left]
int pivotIndex=partition1(a,left,right);
quickSortInter(a,left,pivoteIndex-1);
quickSortInter(a,pivoteIndex+1,right);
}
private static int partiton1(int[] a,int left,int right){
int begin=left;              //hoare
int end=right;
int pivte=a[left];
while(begin<end){
while(begin<end&&a[end]>pivote){
end--;
}
while(begin<end&&a[begin]<privote){
begin++;
}
swap(a,begin,end);
}
return begin;
}
private static int partition2(int[] a.int left,int right){
int begin=left;              //挖坑
int end=right;
int pivote=a[left];
whil(begin<end){
while(begin<end&&a[end]>pivote){
end--;
}
a[begin]=a[end];
whie(begin<end&&a[begin]<pivote){
begin++;
}
a[end]=a[begin];
}
a[begin]=pivote;
return begin;
}
private static int partition3(int[] a,int left,int right){
int pivote=a[left];           //前后下标
int de=left+1;
for(int i=left+1,i<=right;i++){
if(a[i]<pivote){ 
swap(a,i,d++);
}
}
swap(a,left,d-1);
return d-1;
}
private static void swap(int[] a,int i,int j){
int t=a[i];
a[i]=a[j];
a[j]=t;
}
}