A. 算法 求大数组里面的前K大的数
取X=K-b，则前K-1个数字中，有K-b （X）个与第K大的数字GK在同一组的时候，我们无法得到正确的答案。所以， （该算法失效的概率）=（数组分成M组后，前K-1个数字中至少X个与第K个同一组的概率）=(前K-1个数字中至少X个与第K个同一组的方案数/总的区分方案)
前K-1个数字中至少X个与第K个同一组的方案数= 累加（i=X->K-1）(C(K-1，i))*（每组个数10^10/M的全排列)
总方案数=10^10的全排列 /（每组个数10^10/M的全排列的M次方）/(M的全排列)
B. 找数组中第K大的数 请教
可以考虑冒泡算法，就是先把数组里面的数值按照大小现行排列，之后输出第k-1个就行
C. n个已排序的数组，合并后求总数组的第K大元素，有什么好的算法谢谢(提示:不是传统的算法)
什么是传统的算法？ 先取每个数组中的前k大的元素 跑一次归并排序 然后一旦超过k 剩下的就不要了 最后就找出来了 复杂度因为不断扔掉k以后的元素 所以做了剪枝 不算很高
也可以用堆维护一下 不过不太好用
您好 有什么问题再问嘛
D. 设计一个算法，用最少的比较次数，找出n个数中的前k个最大数
用堆排序，建大根堆，每一趟排好一个记录
E. 非递归的o（n）的求n个数里面第k大数的算法
如果ai范围小,如ai<=10000000,则使用桶排。
否则使用楼上的方法，加入二分思想O（n*logk）；
在求中位数时，其实也可以想出O（nlogn),并且O（nlogai）的算法是存在的。
如果是长整型，则O<=310000000,很不错。
F. 算法:平衡树求第k大数 Sm 前段时间刚学会了用快速排序来求一个列中的第 k大数，可是她觉得每次 序列被改变
算法描述
设第k个数为标准比a[k-1]大的数放到其左边，比他小的，放到其右边，其中保持a[k-1]是前k个数中最大的值
#include<iostream>
#include<string>
using namespace std;
int a[10000];
//寻找前k个数中的最大值
int found(int k){
int i;
int max=a[0],flag=0;
for(i=0;i<k;i++)
if(max<a[i]){
max=a[i];
flag=i;
}
return flag;
}
void change(int &a,int &b){
if(a==b)
return;
int t;
t=a;
a=b;
b=t;
}
int main()
{
int n,k,i,flag;
while(cin>>n>>k){
memset(a,0,sizeof(a));
if(k>n)
continue;
for(i=0;i<n;i++)
cin>>a[i];
flag=found(k);
change(a[flag],a[k-1]);
for(i=k;i<n;i++){
if(a[i]<a[k-1]){
change(a[i],a[k-1]);
flag=found(k);
change(a[flag],a[k-1]);
}
}
cout<<a[k-1]<<endl;
}
return 0;
}
G. topk求出的前k大数是否有序
A。（在堆排序和快速排序中，若原始记录接近正序或反序，则选用_堆排序____，若原始记录无序，则最好选用__快速排序___。）C错了。C的原题是下列排序法中，时间复杂度不收数据初始状态影响，总是为O(n2）的是__直接选择排序____。
H. java求前k个最大数1秒内循环10000次
问题描述：求一个数组的最大k个数，如，{1,5,8,9,11,2,3}的最大三个数应该是，8,9,11
问题分析：
1.解法一：最直观的做法是将数组从大到小排序，然后选出其中最大的K个数，但是这样的解法，复杂度是O（logn*n），但是有时候并不需要排序，用简单的选择排序，或者是冒泡排序，那么就K轮的交换或者是选择，就可以得出结论，复杂度是O（n*k），当K很大的时候排序可能是更好的解法，当K小的时候用选择或者是冒泡效率会更加的高。但是这都是会对前K个数进行排序，所以效率不高，当K很大的时候，以上两种方法效率都不是很高。
2.解法二：不对前K个数进行排序，回忆快排的算法中，那个partition函数，就是随机选择数组中的一个数，把比这个数大的数，放在数组的前面，把比这个数小的数放在数组的
后面，这时想如果找出的随机数，最终位置就是K，那么最大的K个数就找出来了，沿着这个思路思考问题，但是这个函数，最后的索引位置并不一定是K，可能比K大也可能比K小，我们把找出的数组分成两部分sa，sb，sa是大的部分，sb是小的部分，如果sa的长度等于K的话，那么直接返回就是最终结果，如果sa的长度要比K大的话，那么以sa为新的数组，从sa中找出K个最大的数，这时候就把原始数据集减少到的sa，如果sa的长度比K小的话，加入sa中有m个元素，那么m个元素算作是K中元素的一部分，再从sb中找到，k-m个最大的元素，组合起来就是最终的结果，那么这时把问题简化成从sb中找k-m个最大的元素，所以总体来说这是一个递归的过程，虽然复杂大也是O（n*logn）但是，每一次数据量都会减少所以会更加的快。
3.解法三：是利用堆排序，建立一个K阶最大堆，然后数据一个个插入队当中，那么插入队的时间复杂度是O（logK），适合数据量比较大的时候，用堆的效果更加好。
I. 从n个数中取出m个最大的最好的算法是什么
有很多算法，复杂度也不尽相同。以下简单举几个例子：
1. n×m遍扫描
【算法基本描述】n×m遍扫描
【算法思想】每次都扫描一遍数组，取出最大元素，这样扫描m遍就能得到m个最大的数
【算法复杂度】O(nm)
2.排序后取最大m个数
【算法基本描述】对n个数排序，对拍完序后的序列取m个最大的数
【算法复杂度】视排序的复杂度，一般为O(nlogn)或O(n^2)
3.最小堆
【算法基本描述】一遍扫描+最小堆
【算法伪代码】
00-建立一个最小堆（优先队列），最小堆的大小控制在m之内
01-for 每个数：
02-----if 这个数比最小堆的堆顶元素大：
03---------弹出最小堆的最小元素
04---------把这个数插入到最小堆
05-最小堆中的m个元素就是所要求的元素
06-其中最小堆的作用就是保持里面始终有m个最大元素，且m个元素中最小的元素在堆顶。
【算法复杂度】O(nlogm) 遍历O(n) 最小堆O(logm)
【其他】如果要求n个数中取最小的m个，只要把算法反一下即可
总结：当n与m差不多大时，采用复杂度较低的排序是比较可取的，因为简单。当m<<n时，排序是很浪费时间的，因为我们不需要后(n-m)个数，所以可以采用最小堆的方法。
我不敢说我的算法是最好的，但是它一定是一个复杂度较低的算法。
J. 求一个算法把n个数中的第k大的数求出来，要求时间复杂度为O（n）
int heapsort(int *data1, int n, int bigk)//利用堆排序，存在一种优化方案：建立K大的堆
{
int data[] = {1,343,34,23,56,234,787,25};
//Part 1
int i, j, j2, k;
int tmp;
for(k = (n>>1) - 1; k >= 0; k--)
{
tmp = data[k];
for(j = k; (j<<1) <= n-2; j = i)
{
j2 = j << 1;
if(j2+2 > n-1)
i = j2 + 1;
else
{
if(data[j2+1] < data[j2+2])
i = j2+2;
else
i = j2+1;
}
if(tmp < data[i])
data[j] = data[i];
else
break;
}
data[j] = tmp;
}
//Part 2
int range = n - bigk;
for(k = n-1; k > range -1; k--)
{
tmp = data[k];
data[k] = data[0];
for(j = 0; (j<<1) <= k-2; j = i)
{
j2 = j<<1;
if(j2+2 > k-1)
i = j2+1;
else
{
if(data[j2+1] < data[j2+2])
i = j2+2;
else
i = j2+1;
}
if(tmp < data[i])
data[j] = data[i];
else break;
}
data[j] = tmp;
}
return data[range];
}
//堆的方法虽然看起来复杂，却绝对是高效的算法