非递归且最坏情况下仍然为O(n)的第K大数程序

http://acm.hit.edu.cn/hoj/problem/view?id=3137

利用上述此题来进行验证，代码如下：

#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdlib>
#include<utility>
#include<stack>
using namespace std;
const int block_size = 5;
int findKth(vector<int>&,int,int,int);
int insert_sort(vector<int> &arr, int start, int end){
    for(int i = start+1; i <= end; i++){
        int key = arr[i],j = i-1;
        for(;j>=start && key<arr[j];j--){
            arr[j+1] = arr[j];
        }
        arr[j+1] = key;
    }
    return arr[start+((end - start)>>1)];
}
vector<int> push_medians(vector<int> &arr, int start, int end){
    vector<int> medians;
    int i, extra = ((end - start + 1) % block_size) > 0;
    end -= extra * block_size;
    for(i = start; i <= end; i += block_size){
        medians.push_back(insert_sort(arr, i, i + block_size - 1));
    }
    if(extra){
        medians.push_back(insert_sort(arr, i, end));
    }
    return medians;
}
int find_median(vector<int> &arr,int start,int end){
    vector<int> medians = push_medians(arr, start, end);
    return findKth(medians,0,medians.size()-1,(medians.size()-1)>>1);
}
int findKth(vector<int> &arr,int start,int end,int k){
    if(start > end){
        return -1;
    }
    stack<pair<int,int> > stk;
    stk.push(make_pair(start,end));
    while(!stk.empty()){
        start = stk.top().first;
        end = stk.top().second;
        stk.pop();
        if(end-start+1<=block_size){
            insert_sort(arr,start,end);
            return arr[k];
        }else{
            int pivot = find_median(arr, start, end);
            for(int i = start; i <= end; i++){
                if(arr[i] == pivot){
                    swap(arr[i], arr[end]);
                    break;
                }
            }
            int small = start - 1;
            for(int i = start; i < end; i++){
                if(arr[i]<arr[end]){
                    swap(arr[++small],arr[i]);
                }
            }
            swap(arr[++small],arr[end]);
            if(small == k){
                return arr[k];
            }
            if(small < k && small < end){
                stk.push(make_pair(small+1,end));
            }
            if(small > k && start < small){
                stk.push(make_pair(start,small-1));
            }
        }
    }
}
int main(int argc, char* argv[]){
    ios::sync_with_stdio(false);
    int n,k;
    while(cin>>n>>k){
       vector<int> arr;
       for(int i=0;i<n;i++){
         int val;
         cin>>val;
         arr.push_back(val);
       }
       cout<<findKth(arr,0,arr.size()-1,n-k)<<endl;
    }
}

以下证明一下为何在最坏情况下其时间复杂度仍然为O(N)，

摘自：http://blog.csdn.net/v_july_v/article/details/6431001

总体意思就是：

每次进行Median of Median操作的时候都可以保证可以最少去掉30%的数据，

结论得来的不等式如下：

不等式的含义是对于长度为n的数组，那么其至少得有n/5个子数组（每个数组的长度理论上均为5），然后你考虑比Median of Median大的数的数量的最小值

显然至少要有1/2 * (n/5)个子数组有比Median of Median大的数，其中每个子数组里头比Median of Median大的数至少得有三个，除了两个子数组以外，

这两个子数组分别为Median of Median所在的子数组本身以及长度不及5的子数组，因此就得到了上述不等式。

同理可以推出Median of Median小的数的数量的最小值，

因此我们可以推出以下不等式，第一项是计算Median of Median的时间复杂度，第二项为计算剩余数字的时间复杂度，第三项是当前轮的时间复杂度