快速排序，是一种速度快，效率高的排序算法。

思路：

      在要排的数（比如数组A）中选择一个中心值（如A[0]），通过一趟排序将数组A划分成两部分，其中以Key为中心，key右边都比key大，key左边都比key小，然后对这两部分分别重复这个过程，直到整个有序。

        整个快排的过程就简化为了一趟排序的过程，然后调用递归就行了。

        一趟排序的方法：

1. 定义i=0,j=A.length-1,i为第一个数的下标，j为最后一个数下标
2. 从数组的最后一个数Aj从右往左找，找到第一个小于key的数，计为Aj
3. 从数组的第一个数Aj从左往右找，找到第一个大于key的数，计为Aj
4. 交换Aj和Ai
5. 重复这一过程，直到 i = j
6. 调整key的位置，把A[i]和key交换

       选择 key=5 , 开始时 i=0, j=7

      index   0 1 2 3 4 5 6 7 

开始：           5 2 8 9 2 3 4 9

第一次查找：5 2 8 9 2 3 4 9

                             i           j

交换：           5 2 4 9 2 3 8 9

                             i           j

第二次查找：5 2 4 9 2 3 8 9

                               i      j

交换：           5 2 4 3 2 9 8 9

                                i     j

第三次查找：5 2 4 3 2 9 8 9

                                  ij

调整key:        2 2 4 3 5 9 8 9

                                  ij

代码实现：

public class QuickSort{
    public static void main(String[] args){
        int[] a={1,2,4,5,7,4,5,3,9,0};
        System.out.println(Arrays.toString(a));
        quickSort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void quickSort(int[] a){
        if(a.length>0){
            quickSort(a,0,a.length-1);
        }
    }

    private static void quickSort(int[] a,int low,int high){
        //1，找到递归算法的出口
        if(low > high){
            return;
         }
        //2，存
         int i=low;
         int j=high;
        //3，key
        int key=a[low];
        //4,完成一趟排序
        while(i < j){
            //从右往左找到第一个小于key的数
            while(i<j && a[j]>key){
                j--;
            }
            //从左往右找到第一个大于key的数
            while(i<j && a[i]<key){
                i++;
            }
            //交换
            if(i<j){
                int tem=a[i];
                a[j]=a[i];
                a[j]=tem;
             }
           }
             //调整key的位置
             int tem=a[i];
             a[i]=a[low];
             a[low]=tem;
             //对key的左边的数快排
             quickSort(a,low,i-1);
             //对key的右边的数快排
             quickSort(a,i+1,high);
         }
    }