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

问题：

输入：一个包含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;
}