这个问题的解决方法很多啊，一下列举一下
1 基于排序的传统方法 O(nlogn)
如果你只需要找一次第k小的数，这不是一个好方法。。。如果你要找n次，还是用排序吧
2 Las Vegas概率算法
也可以称之为随机化算法，其算法的特点优点类似于快速排序，都是需要选择pivot，然后进行划分。把一个序列划分为3部分，x 小于x 和大于x的。。然后根据k的取值，进行递归计算。
毕竟是LasVegas算法，其最坏时间复杂度很差，是O(n^2)。。当然，平均复杂度非常好 O(n) 如果学过随机化算法，证明不难！
3 基于r划分的O(n)算法
这个算法可以说是一个trick，他的思想就是想优化LasVegas算法中的pivot选择。。所以才会有这个算法。假设我们把r取成5的话，以每5个元素为子集划分源数组，然后对每个子集排序求出中位数，这样的中位数集合组成一个新的序列M，对M递归的求解其中位数p，得到的p即为划分点。p将源数组划分为3部分：
* s1：所有小于p的元素
* s2: 所有等于p的元素
* s3: 所有大于p的元素
下一轮迭代的时候根据输入的level参数判断该剪去哪部分元素。
这样，每一轮迭代至少剪去n/4的元素（画个中位数排列的图出来就容易看出），则最坏情况下的时间复杂度表示为：
T(n)<=T(3n/4)+T(n/5)+O(n)
其中
* T(3n/4)是下一轮迭代的最大数据量情况下的时间复杂度
* T(n/5)是求寻找中位数组成集合的中位数的时间复杂度
利用归纳法，可以很清楚的证明出来T(n) <=20cn (c为常数)
基于r划分的算法，其最坏时间复杂度是O(n)。。感觉是不是很优秀！但是，优秀的代价是你的常数因子太大了！！！
平时在选择算法的时候，基本上可以说是一边倒的选择Las Vegas算法！
此外，在解决问题的时候，最好看清楚题目的情景，如果题目要求n个数中的第k个数，但是k取从1-n。。。那么还是用基于排序的吧。。。毕竟做了O(nlogn)的工作之后，每次都是O(1)搞定。。而LasVegas算法和基于r划分的方法都要O(n^2)
基于LasVegas算法的代码：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
#define Max 10000
int cnt=0;
int select( int *a, int b, int e, int k) //从b到e
{
cnt++;
if (b==e) return a[b];
int x=a[b+rand()%(e-b+1)],i=b,j=e;
i--;j++;
while (i<j)
{
while (a[++i] < x); while (a[--j] > x);
if (i<j)std::swap(a[i],a[j]);
}
if (j==e)j--;i=j-b+1;
if (k <=i) return select(a,b,j,k);
else return select(a,j+1,e,k-i);
}
int main()
{
int a[Max];
for(int i=0;i<Max;i++)
a[i]=i;
random_shuffle(a,a+Max);
int b[Max];
for(int i=0;i<Max;i++)
b[i]=a[i];
cout<<endl;
vector<int> C;
for(int i=0;i<Max;i++)
{
cnt=0;
select(a,0,Max-1,i);
for(int i=0;i<Max;i++)
a[i]=b[i];
C.push_back(cnt);
}
sort(C.begin(),C.end());
cout<<C[0]<<endl;
cout<<C[C.size()-1]<<endl;
return 0;
}
从代码结果可以看出LasVegas算法表现还是很优秀的，毕竟10000个数，最深递归层次是35层！
此外，当然求第k小元素的各种复杂数据结构也可以做，而且效率也可以，看第四种方法： (这种方法等以后再总结吧。。)
回顾树状数组的定义，注意到有如下两条性质：
一，c[ans]=sum of A[ans-lowbit(ans)+1 ... ans];
二，当ans=2^k时，
c[ans]=sum of A[1 ... ans];
下面说明findK(k)如何运作：
1，设置边界条件ans,ans'<maxn且cnt<=k；
2，初始化cnt=c[ans]，其中ans=2^k且k为满足边界条件的最大整数；
3，找到满足边界条件的最大的ans'使得ans'-lowbit(ans')=ans，即ans'满足c[ans']=A[ans+1 .. ans']（根据性质一），只要将c[ans']累加到cnt中（此时cnt=sum of A[1 ... ans']，根据性质二），cnt便可以作为k的逼近值；
4，重复第3步直到cnt已无法再逼近k，此时ans刚好比解小1，返回ans+1。
因此findk(k)的实质就是二分逼近
/**********************************
树状数组实现查找K小的元素
经典。
限制：数据范围在1<<20 以内
***********************************/
#include <iostream>
using namespace std;
#define maxn 1<<20
int n,k;
int c[maxn];
int lowbit(int x){
return x&-x;
}
void insert(int x,int t){
while(x<maxn){
c[x]+=t;
x+=lowbit(x);
}
}
int find(int k){
int cnt=0,ans=0;
for(int i=20;i>=0;i--){
ans+=(1<<i);
if(ans>=maxn || cnt+c[ans]>=k)ans-=(1<<i);
else cnt+=c[ans];
}
return ans+1;
}
void input(){
memset(c,0,sizeof(c));
int t;
scanf("%d%d",&n,&k);
for(int i=0;i<n;i++){
scanf("%d",&t);
insert(t,1);
}
printf("%d\n",find(k));
}
int main(){
int cases;
scanf("%d",&cases);
while(cases--){
input();
}
return 0;
}