一、解决方案
    pv = 最后元素为基准点元素；
    j：找比基准点元素小的，一旦找到就和i交换；
    i：++，最后与pv交换，即为分区的位置。
    递归调用，将基准点左边和基准点右边的元素分区排序，直到l>=h。
    二、代码

    1. public class QuickSort {
    2.     public static void main(String[] args){
    3.         int[] a = {5,3,7,2,9,8,1,4};
    4.         quick(a,0,a.length-1);
    5.     }
    7.     //递归实现
    8.     public static void quick(int[] a,int l,int h){
    9.         if(l>=h){
    10.             return;
    11.         }
    12.         int p = partition(a,l,h);
    13.         quick(a,l,p-1);
    14.         quick(a,p+1,h);
    15.     }
    17.     //一趟快排
    18.     private static int partition(int[] a,int l,int h){
    19.         int pv = a[h];
    20.         int i = l;
    21.         for (int j = l; j < h; j++) {
    22.             if(a[j]<pv){
    23.                 swap(a,i,j);
    24.                 i++;
    25.             }
    26.         }
    27.         swap(a,h,i);
    28.         System.out.println(Arrays.toString(a));
    29.         return i;
    30.     }
    32.     public static void swap(int[] a,int i,int j){
    33.         int tmp = a[i];
    34.         a[i] = a[j];
    35.         a[j] = tmp;
    36.     }
    37. }