最基本的劃分點由數組的最後一個值來確定，現在是將數組的最後一個值的前一個數值作為劃分點，但是需要經過三項取一方法的變換，最後它位置上的值是三個中最大的。

public class ArrayIns {
    private long [] a;
    private int nElems;
    public ArrayIns(int maxSize) {
        a=new long[maxSize];
        nElems=0;
    }
    public void insert(long value) {
        a[nElems]=value;
        nElems
 
++;
    }
    public int size() {
        return nElems;
    }
    public void display() {
        for(int j=0;j<nElems;j++) {
            System.out.print(a[j]+" ");
        }
        System.out.println();
    }
    public void quickSort() {
        recQuickSort(0, nElems-1);
    }
    //遞歸方法
    public
 
 void recQuickSort(int left,int right) {
        int size=right-left+1;
        //這個可以進行改進
        if(size<=3) {
            //剩下三個，就手工判斷
            manualSort(left,right);
        }else{
            long median=medianOf3(left,right);
            //pivot可以進行改進
            long pivot=median;
            
 
int partition=partitionIt(left, right, pivot);  //由劃分方法return得到
            recQuickSort(left, partition-1);//前部分再劃分
            recQuickSort(partition, right);//後部分再劃分
        }
    }
    private long medianOf3(int left, int right) {
        //三項數據取中間大小的值作為劃分點
        int center=(left+right)/2;
        if(a[left]>a[center])
            swap(left, center);
        if(a[left]>right)
            swap(left, right);
        if(a[center]>a[right])
            swap(center, right);
        swap(center, right-1);
        return a[right-1];
    }
    private void manualSort(int left, int right) {
        int size=right-left+1;
        //判斷當前需要劃分的數組的大小
        if(size<1)
            return;
        if(size==2) {
            if(a[left]>a[right]) {
                swap(left, right);
                return ;
            }            
        }else {
            if(a[left]>a[right-1])swap(left, right-1);
            if(a[left]>a[right])swap(left, right);
            if(a[right-1]>a[right])swap(right-1, right);
        }
        
    }
    public int partitionIt(int left,int right,long pivot) {
        int leftPtr=left;
        int rightPtr=right-1;
        while(true) {
            //左邊找大於特定值的
            while( a[++leftPtr]<pivot);
            //右邊找小於特定值的
            while(a[--rightPtr]>pivot);
            if(leftPtr>=rightPtr)
                break;
            else
                //交換指向的值
                swap(leftPtr, rightPtr);
        }
        swap(leftPtr, right-1);
        return leftPtr;
        
    }
    public void swap(int dex1,int dex2) {
        long temp;
        temp=a[dex1];
        a[dex1]=a[dex2];
        a[dex2]=temp;
    }

}

public class Test {

    public static void main(String[] args) {
        int maxSize=100;
        ArrayIns arrayPar=new ArrayIns(maxSize);
        arrayPar.insert(60);
        arrayPar.insert(30);
        
        arrayPar.insert(80);
        arrayPar.insert(10);
        arrayPar.insert(70);
        arrayPar.insert(90);
        arrayPar.insert(00);
        arrayPar.insert(20);
        arrayPar.insert(40);
        arrayPar.display();
        arrayPar.quickSort();
        arrayPar.display();

    }

}

排序_快速排序_另一種取劃分點的方法