经典算法总结之线性时间做选择

问题：

输入：一个包含n个(不同的)数的集合A和一个数i， 1 <= I <= n。

输出：元素x∈A， 它恰大于A中其他的I – 1个元素（即求第k小数）。

本博文中寻找最大的K个数(TOP K算法)这篇文章也用了本文中的算法，大家可以参考。

三种算法：

1、 直接排序，输出数组第i个元素即可, 时间复杂度为O(nlgn)

2、 这种算法，利用“快排的或者类似二分”的思想，每次以枢纽为界，分两边，每次只需处理一边即可（抛弃另一边），平均情况下的运行时间界为O(n)，这种算法以期望时间做选择。《算法都论》里是，在分治时用随机数来选取枢纽（算法导论中伪代码见图），好吧，这是理论上的算法，它没有考虑实际产生随机数的开销，事实上，效率一点也不高，已经测试过，产生随机数花费的开销真的很大，后边我用更快的三数中值又实现了一遍，思想是一样的，只是效率提高了。





C++完整代码：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int partition(vector<int> &A,int p,int r){
int x = A[r];
int i=p-1;
int temp;
for(int j = p;j<r;++j){
if(A[j]<=x){
++i;
swap(A[i],A[j]);
}
}
swap(A[i+1],A[r]);
return i+1;
}

inline int Random(int low, int high) {
return (rand() % (high - low + 1)) + low;
}

int Randomized_Partition(vector<int> &kp, int low, int high) {
int i = Random(low, high);
swap(kp[high], kp[i]);
return partition(kp, low, high);
}

void randomized_quickSort(vector<int> &A,int p,int r){
if(p<r){
int q = Randomized_Partition(A,p,r);
randomized_quickSort(A,p,q-1);
randomized_quickSort(A,q+1,r);
}
}

int randomized_select(vector<int> A,int p,int r,int i){
if(p==r)
return A[p];
if(p>r) return -1;
int q = Randomized_Partition(A,p,r);
int k = q-p+1;
if(i==k)
return A[q];
else if(i<k)
return randomized_select(A,p,q-1,i);
else return randomized_select(A,q+1,r,i-k);
}

void main(){
int a[10] = {9,10,8,7,6,5,4,3,2,1};
vector<int> A(a,a+10);
cout<<randomized_select(A,0,9,5)<<endl;
}

3、 第三种算法以最坏情况线性时间做选择，最坏运行时间为O(n)，这种算法基本思想是保证每个数组的划分都是一个好的划分，以5为基，五数取分，这个算法，算法导论没有提供伪代码，额，利用它的思想，可以快速返回和最终中位数相差不超过2的数，这样的划分接近最优，基本每次都二分了（算法导论中步骤见图)

/*利用中位数来选取枢纽元,这种方法最坏情况下运行时间是O(n)
这里求的中位数是下中位数算法导论里没有伪代码，
写起来很麻烦注意这里的查找到的中位数，
并不是真正意义上的中位数而是和真正中位数相差不超过2的一个数开始以为我写错了
，又看了算法导论，应该就是这个意思返回的是[x - 1, x + 2]的一个数，中位数是x从下边的输出中也可以看出：*/
#include<iostream>
#include<cstdio>
using namespace std;
const int maxn = 14;//kp -> size
const int maxm = maxn / 5 + 1;//mid -> size
int kp[maxn];int mid[maxm]; //插入排序
void InsertionSort(int kp[], int n) {
for (int j, i = 1; i < n; i++) {
int tmp = kp[i];
for (j = i; j > 0 && kp[j - 1] > tmp; j--) {
kp[j] = kp[j - 1];
}
kp[j] = tmp;
}
} //查找中位数, 保证每一个划分都是好的划分
int FindMedian(int kp[], int low, int high) {
if (low == high) {
return kp[low];
}
int index = low;//index初始化为low
//如果本身小于5个元素，这一步就跳过
if (high - low + 1 >= 5) {         //储存中位数到mid[]
for (index = low; index <= high - 4; index += 5) {
InsertionSort(kp + index, 5);
int num = index - low;
mid[num / 5] = kp[index + 2];
}
}     //处理剩下不足5个的元素
int remain = high - index + 1;
if (remain > 0) {
InsertionSort(kp + index, remain);
int num = index - low;
mid[num / 5] = kp[index + (remain >> 1)];//下中位数
}
int cnt = (high - low + 1) / 5;
if ((high - low + 1) % 5 == 0) {
cnt--;//下标是从0开始，所以需要-1
}//存放在[0…tmp]
if (cnt == 0) {
return mid[0];
} else {
return FindMedian(mid, 0, cnt);
}
} int Qselect(int kp[], int low, int high, int k) {
int pivotloc = FindMedian(kp, low, high);    //这里有点不一样，因为不知道pivotloc下标，所以全部都要比较
int i = low - 1, j = high + 1;
for (; ;) {
while (kp[++i] < pivotloc) {}
while (kp[--j] > pivotloc) {}
if (i < j)  swap(kp[i], kp[j]);
else break;
}     int num = i - low + 1;
if (k == num) return kp[i];
if (k < num) {
return Qselect(kp, low, i - 1, k);
} else {
return Qselect(kp, i + 1, high, k - num);
}
}
int main() {
int kp[maxn] = {10, 14, 8, 11, 7, 1, 2, 13, 3, 12, 4, 9, 6, 5};
for (int i = 0; i < maxn; i++) {
printf("中位数是:  %d\n", FindMedian(kp, 0, maxn - 1));
printf("第%d小的数是:  ", i + 1);
cout <<  Qselect(kp, 0, maxn - 1, i + 1) << endl << endl;
}
return 0;
}