快速排序

参考资料：

• 算法导论
• http://blog.csdn.net/insistgogo/article/details/7785038
• http://blog.csdn.net/michealtx/article/details/7181906
• http://www.oschina.net/code/snippet_186712_6364

代码：

QuickSort.java

package algorithms;

import java.util.Arrays;
import java.util.Random;

import sorts.InsertionSort;

public class QuickSort {
    
    private static final int SMALL_ARRAY_SIZE = 5;
    
    /**
     * sort the array
     * @param array the array to be sorted
     * @param low the lower bound (inclusive)
     * @param high the upper bound (exclusive)
     * */
    public static <T extends Comparable<T>>
    void sort(T[] array, int low, int high) {
        --high; // right the upper bound (exclusive)
        _sort(array, low, high);
    }
    private static <T extends Comparable<T>> void 
    _sort(T[] array, int low, int high) {
        if (high - low + 1 <= SMALL_ARRAY_SIZE) {
            InsertionSort.sort(array, low, high+1); 
        } else {
            int pivotIndex = medianOf3(array, low, high);
            int partition = Partition.doPartition(array, low, high+1, pivotIndex);
            _sort(array, low, partition-1);
            _sort(array, partition+1, high);
        }
    }
    // medianOf3() requires the array's length to be at least 4
    private static <T extends Comparable<T>> int medianOf3(T[] array, int low, int high) {
        int middle = (low + high) / 2;
        if (array[low].compareTo(array[middle]) > 0) {
            swap(array, low, middle);
        }
        if (array[low].compareTo(array[high]) > 0) {
            swap(array, low, high);
        }
        if (array[middle].compareTo(array[high]) > 0) {
            swap(array, middle, high);
        }
        swap(array, middle, high-1);
        return high-1;
    }
    
    private static <T> void swap(T[] array, int index1, int index2) {
        T temp = array[index1];
        array[index1] = array[index2];
        array[index2] = temp;
    }
    
    // test
    public static void main(String[] args) {
        Random random = new Random();
        int num = 10;
        Integer[] a = new Integer[num];
        for (int i = 0; i < num; i++) {
            a[i] = random.nextInt(100);
        }
        System.out.println(Arrays.toString(a));
        QuickSort.sort(a, 0, a.length);
        System.out.println(Arrays.toString(a));
    }
    
}

Partition.java

package algorithms;

public class Partition {
    
    /**
     * 
     * Partition the array into 2 parts, the index range of the left part is [left, i-1], the index range of
     * the right part is [i, right], such that all elements smaller 
     * than the pivot are in the left part and all elements no smaller than the pivot
     * are in the right part.
     * @param left left bound (inclusive)
     * @param right right bound (exclusive)
     * @return the index of the left-most element in the right part, that is, i.
     * */
    public static <T extends Comparable<T>> int doPartition(T[] a, int left, int right, int pivotIndex) {
        --right;
        T pivot = a[pivotIndex];
        swap(a, right, pivotIndex); // set the pivot to the rightmost position
        int i = left - 1;
        for (int j = left; j <= right - 1; ++j) {
            if (a[j].compareTo(pivot)<=0) {
                ++i;
                swap(a, i, j);
            }
        }
        swap(a, i+1, right);
        return i+1;
    }
    
    private static <T> void swap(T[] array, int index1, int index2) {
        T temp = array[index1];
        array[index1] = array[index2];
        array[index2] = temp;
    }

}