快速选择算法

利用快速排序的思想，选择第k大（或小）的数。

具体地，利用快速排序的划分思想，每次将数组划分为两部分，确定该第k大（或小）的元素在哪一个部分，然后对该部分递归进行划分，直到找到第k大（或小）的元素。快速排序期望时间复杂度为O(n log n)，快速选择算法期望时间复杂度为O(n)。

关于枢纽元的选择：

1. 选取第一个或最后一个元素，一般做法。
2. 三数取中值法。取首、中、尾3个位置的元素的中间值，并将该中间值交换至第一个或最后一个元素，继续同1进行排序。
3. 中位数的中位数法。
1. 将所有元素进行组分，如每5个为一组，可分为[n/5]组。
2. 对每个组进行排序，并得到该组的中位数。
3. 递归调用步骤 a, b 直到获得最终的中位数。

快速选择算法的一个实现：（三值取中值法）

package com.yan.algorithmTest;

/**
 * quick select algorithm which is very similar to quick sort algorithm.
 * it suffers the average complication of O(n), while quick sort algorithm suffers O(n log n).
 * @author Yan
 *
 */
public class QuickSelectTest {
    private static int[] data = new int[] { 5, 3, 4, 6, 2, 1, 7, 8, 10, 9 };
    private static int k = 4;

    public QuickSelectTest() {
    }

    public static void main(String[] args) {
        int result = quickSelect(data, k, 0, data.length - 1);
        System.out.println(result);
    }

    public static int quickSelect(int[] data, int k, int start, int end) {
        if (k > data.length || start > end) {
            return -1;
        }
        /*
         * 与quick sort 相同的partition算法（分割算法）。
         */
        int pivot = end;
        int left = start;
        int right = end;
        while (left < right) {
            while (data[left] <= data[pivot] && left < right) {
                left++;
            }
            while (data[right] >= data[pivot] && left < right) {
                right--;
            }
            swap(data, left, right);
        }
        swap(data, left, pivot);
        /*
         * 与快速排序相同，只是在recurse时，多了两个判断，即k的判断。因此，只有一个递归调用会执行。 相较于快速排序的期望时间复杂度O(n
         * log n)，快速选择的期望时间复杂度为O(n)。
         */
        if (k - 1 > left) {
            quickSelect(data, k, left + 1, end);
        }
        if (k - 1 < left) {
            quickSelect(data, k, start, left - 1);
        }

        return data[k - 1];
    }

    /*
     * median-of-three，三值取中值法，获取首、中、尾三者中得中间值，并与枢纽元pivot，即尾（或首）交换。
     */
    public static void medianPivot(int[] data, int start, int end) {
        int center = (start + end) >> 1;
        if (data[start] > data[center]) {
            swap(data, start, center);
        }
        if (data[center] > data[end]) {
            swap(data, end, center);
        }
        if (data[start] > data[end]) {
            swap(data, end, start);
        }
        swap(data, end, center);
    }

    public static void swap(int[] data, int x, int y) {
        int temp = data[x];
        data[x] = data[y];
        data[y] = temp;
    }
}