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];
}
//堆的方法雖然看起來復雜，卻絕對是高效的演算法