选择问题的线性期望时间算法

    由于我们能够以O(NlogN)时间给数组排序，因此可以期望为选择问题得到一个更好的时间界。我们这里介绍的查找集合S中第k个最小元的算法几乎与快速排序相同。事实上，其前三步是相同的。我们把这种算法叫做快速选择(quickselect)。令|S_i|为S_i中元素的个数，快速选择的步骤如下：
 1)如果|S|=1，那么k=1并将S中的元素作为答案返回。如果正在使用小数组的截止方法且|S|≤CUTOFF，则将S排序并返回第k个最小元。
2)选取一个枢纽元v∈S。
3）将集合S-{v}分割成S₁和S₂，就像快速排序中所做的那样。
4）如果k≤|S₁|，那么第K个最小元必然在S₁中。在这种情况下，返回quickselect(S_1,k).如果k=1+|S₁|，那么枢纽元就是第k个最小元，将它最为答案返回。否则，第k个最小元就在S₂中，他是S₂中的第(k-|S₁|-1)个最小元。我们进行一次递归调用并返回quickselect(S_2,k-|S₁|-1).
      与快速排序对比，快速选择只进行了一次递归调用而不是两次。快速选择的最坏情形和快速排序的相同，也就是O(N²)。直观看来，这是因为快速排序的最坏情形发生在S₁和S₂有一个是空的时候；于是，快速选择也就不是真的节省一次递归调用。不过平均运行时间是O(N)。具体分析类似快速排序的分析。
       快速排序的实现甚至比抽象描述还要简单，其程序如下。当算法终止时，第k个最小元就在位置k-1上(因为数组开始于下标0)。这破坏了原来的排序；如果不希望这样，那么需要做一份拷贝。

/**//**
 * Simple insertion sort.
 */
template <typename Comparable>
void insertionSort( vector<Comparable> & a )
...{
    for( int p = 1; p < a.size( ); p++ )
    ...{
        Comparable tmp = a[ p ];

        int j;
        for( j = p; j > 0 && tmp < a[ j - 1 ]; j-- )
            a[ j ] = a[ j - 1 ];
        a[ j ] = tmp;
    }
}

/**//**
 * Return median of left, center, and right.
 * Order these and hide the pivot.
 */
template <typename Comparable>
const Comparable & median3( vector<Comparable> & a, int left, int right )
...{
    int center = ( left + right ) / 2;
    if( a[ center ] < a[ left ] )
        swap( a[ left ], a[ center ] );
    if( a[ right ] < a[ left ] )
        swap( a[ left ], a[ right ] );
    if( a[ right ] < a[ center ] )
        swap( a[ center ], a[ right ] );

        // Place pivot at position right - 1
    swap( a[ center ], a[ right - 1 ] );
    return a[ right - 1 ];
}


/**//**
 * Internal selection method that makes recursive calls.
 * Uses median-of-three partitioning and a cutoff of 10.
 * Places the kth smallest item in a[k-1].
 * a is an array of Comparable items.
 * left is the left-most index of the subarray.
 * right is the right-most index of the subarray.
 * k is the desired rank (1 is minimum) in the entire array.
 */
template <typename Comparable>
void quickSelect( vector<Comparable> & a, int left, int right, int k )
...{
    if( left + 10 <= right )
    ...{
        Comparable pivot = median3( a, left, right );

            // Begin partitioning
        int i = left, j = right - 1;
        for( ; ; )
        ...{
            while( a[ ++i ] < pivot ) ...{ }
            while( pivot < a[ --j ] ) ...{ }
            if( i < j )
                swap( a[ i ], a[ j ] );
            else
                break;
        }

        swap( a[ i ], a[ right - 1 ] );  // Restore pivot

            // Recurse; only this part changes
        if( k <= i )
            quickSelect( a, left, i - 1, k );
        else if( k > i + 1 )
            quickSelect( a, i + 1, right, k );
    }
    else  // Do an insertion sort on the subarray
        insertionSort( a, left, right );
}