快速排序

情景：对数组 int[] arr = {7，10，1，9，2，5，8，6，4 ，3}中的数据 从小到大排序。

思路：选择最右侧的元素3作为枢纽元素，然后从左到右，从下标为0的元素开始与枢纽元素比较，小于枢纽元素不做任何处理，继续比较下一个，直至遇到大于枢纽元素的A元素；同时从右向左，从下标为arr.length-2的元素开始与枢纽元素比较，同理，直至遇到小于枢纽元素的元素B，然后交换A和B；直至把枢纽元素放到应该放的位置。然后按照同样的方法，递归调用自己的方法，继续对枢纽元素左侧的数组排序，对枢纽元素右侧的数组排序。

代码：

/**
 * 快速排序
 * 
 * @author D N
 *
 */
public class QuickSort {
    private long[] a;
    private int nElems;

    public QuickSort(int max) {
        a = new long[max];
        nElems = 0;
    }

    public void insert(long value) {
        a[nElems] = value;
        nElems++;
    }

    public void display() {
        for (int j = 0; j < nElems; j++) {
            System.out.print(a[j] + "   " + "" + "");
        }
        System.out.println("");
    }

    // 快速排序算法
    public void quickSort() {
        qecQuickSort(0, nElems-1);
    }

    public void qecQuickSort(int left,int right) {
        if(right-left <= 0)   // 说明已经是排序状态了
            return;
        else{
            long pivot = a[right]; // 选择最右侧的元素作为枢纽
            int partition = partitionIt(left, right, pivot); // 这个位置就是枢纽元素被放置的位置，也就是该枢纽元素最终排序后的位置
            qecQuickSort(0, partition-1); // 对枢纽左侧的元素排序
            qecQuickSort(partition+1, right); //对枢纽右侧的元素排序
        }
    }
    
    public int partitionIt(int left,int right,long pivot){
        int leftPtr = left-1;
        int rightPtr = right;
        while(true){
            while(a[++leftPtr] < pivot)
                ;
            while(rightPtr > 0 && a[--rightPtr] > pivot)
                ;
            if(leftPtr >= rightPtr)
                break;
            else {
                swap(leftPtr, rightPtr);
            }
        }
        swap(leftPtr, right);
        return leftPtr;
    }
    
    public void swap(int one,int two){
        long temp = a[one];
        a[one] = a[two];
        a[two] = temp;
    }
}

运行测试代码：

public class SortTest {
    public static void main(String[] args) {
        int maxSize = 10;
        QuickSort arr = new QuickSort(maxSize);
        arr.insert(7);
        arr.insert(10);
        arr.insert(1);
        arr.insert(9);
        arr.insert(2);
        arr.insert(5);
        arr.insert(8);
        arr.insert(6);
        arr.insert(4);
        arr.insert(3);
        arr.display();
        System.out.println();
        arr.quickSort();
        System.out.println();
        arr.display();
    }
}

运行结果：

7   10   1   9   2   5   8   6   4   3   


1   2   3   4   5   6   7   8   9   10   

效率分析：快速排序的时间复杂度是O(N*_logN)，它在这几种排序算法中效率最高。