2. 程式人生 > >第K大/Top K及其簡單實現

第K大/Top K及其簡單實現

阿新 • • 發佈：2018-12-31

見網上第K大多數只給思路，沒給實現，我就來填坑了。

update 2017-09-23 有同學反饋說面試遇到這個題，博文給了助攻，哈預料之中。

Top K 和第K大基本等價，以下我們以第K大為例且假設第K大一定存在，Top K 可以在第k大基礎上稍微改動獲得。
本文介紹6種方法，只考慮實現功能，不做異常判斷，面試的話快排和最小堆的方法比較不錯，測試提交的話可以去Leetcode，或者直接拿最下面的資料生成程式碼去對拍跑。

快排的思想 近似O(n)

呼叫降序快排的partition函式，設區間為[low,high]，返回index，則index左邊都是大於data[index]的。
1. 若index及index左邊數字有k個則data[index]就是第k大，index及其左邊元素為Top K元素
2. 左邊數字大於k個則繼續在[low,index]裡找
3. 左邊數字小於k個則去右邊[index+1,high]找 k - 左邊數字個數

#include <cstdio>
#include <iostream>
using namespace std;
const int maxn = 1e5 + 5;
//改為 data[high] >= key 和 data[low] <= key 則為第k小
int part(int *data, int low, int high) {
    int key = data[low];
    while (low < high) {
        while (low < high && data[high] <= key) high--;
        data[low] = data[high];
        while
 
 (low < high && data[low] >= key) low++;
        data[high] = data[low] ;
    }
    data[low] = key;
    return low;
}
int k_th(int *data, int k, int low, int high) {
    int pos = part(data, low, high);
    int cnt = pos - low + 1;  //[low,pos]元素個數
    if (cnt == k) return data[pos];
    else
 
 if (cnt < k) return k_th(data, k - cnt, pos + 1, high);
    else return k_th(data, k, low, pos);
}
int k_th(int *data, int n, int k) {
    if(k < 1 || k > n) return -1;
    return k_th(data, k, 0, n - 1); //閉區間
    //遍歷data[0,k)即可獲得top K，但不能保證有序
}

int main() {

    // int data[] = {1, 5, 6, 7, 3, 2, 10, 9, 0, 231, 3214, 61};
    // int n = sizeof(data) / sizeof(int);
    // int k = 2;
    // cout << k_th(data, n, k) << endl;

    // freopen("in.txt","r",stdin);
    // freopen("out.txt","w",stdout);
    int n, k, data[maxn];
    std::ios::sync_with_stdio(false);
    while (cin >> n >> k) {
        for (int i = 0; i < n; ++i) {
            cin >> data[i];
        }
        cout << k_th(data, n, k) << endl;
    }
    return 0;
}

小根堆 O(nlogk)

維護一個k個元素的小根堆，保持堆裡元素為最大的K個且堆頂為第k大(堆裡最小的)，掃一遍資料，若堆裡個數小於k則插入，否則看新的數和堆頂數大小關係：
1. 若新來的數小於等於堆頂，即新元素比Top K裡最小的還小，則新來的數顯然不可能是前k大
2. 若新來的數大於堆頂，則刪掉堆頂，將新數字放到堆裡且調整堆來保持堆的屬性

由於實現堆程式碼量較多，我們可以用C++的優先佇列、set等代替手工堆偷跑，當然這裡也提供了手動實現版。

#include <cstdio>
#include <vector>
#include <queue>
#include <iostream>
using namespace std;
const int maxn = 1e5 + 5;
//維持一個k大小的最小堆，根據新元素和堆頂大小決定要不要加入堆且刪堆頂
// O(nlogk)
int biggest_k_th(int *data, int n, int k) {
    priority_queue<int, vector<int>, greater<int> >q;   //小根堆
    while (!q.empty()) q.pop();

    for (int i = 0; i < n; ++i) {
        if (q.size() < k) {
            q.push(data[i]);
        } else if (data[i] > q.top()) {
            q.pop();
            q.push(data[i]);
        }
    }
    //取k次q.top()且pop()k次即為有序的前K大
    return q.top();
}

int smallest_k_th(int *data, int n, int k) {
    priority_queue<int>q;   //大根堆
    while (!q.empty()) q.pop();

    for (int i = 0; i < n; ++i) {
        if (q.size() < k) {
            q.push(data[i]);
        } else if (data[i] < q.top()) {
            q.pop();
            q.push(data[i]);
        }
    }
    return q.top();
}

int main() {
    // freopen("in.txt","r",stdin);
    // freopen("out.txt","w",stdout);
    std::ios::sync_with_stdio(false);
    int n, k, data[maxn];
    while (cin >> n >> k) {
        for (int i = 0; i < n; ++i) {
            cin >> data[i];
        }
        cout << biggest_k_th(data, n, k) << endl;
    }
    return 0;
}

手動實現版

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 1e5 + 5;
const int maxK = 1e5 + 5;

int heapCnt = 0;
int heap[maxK];

void adjust(int *heap, int begin, int end) {    //[begin,end)
    int cur = begin;
    int son = 2 * cur + 1;
    while (son < end) {
        if (son + 1 < end && heap[son] > heap[son + 1]) son++;
        if (heap[cur] < heap[son]) return;
        swap(heap[son], heap[cur]);
        cur = son;
        son = 2 * cur + 1;
    }
}

void buildHeap(int *heap, int k) {  //[heap,heap+k) 開區間
    for (int i = k / 2; i >= 0;  --i) {
        adjust(heap, i, k);
    }
}

int k_th(int *data, int n, int k) {
    heapCnt = 0;
    for (int i = 0; i < n; ++i) {
        if (heapCnt < k) {
            heap[heapCnt++] = data[i];
            if (heapCnt == k) {
                buildHeap(heap, k); //data[0,k)共k個
            }
        } else {
            if (data[i] > heap[0]) {
                heap[0] = data[i];
                adjust(heap, 0, heapCnt);
            }
        }
    }
    return heap[0];
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    int n, k, data[maxn];
    std::ios::sync_with_stdio(false);
    while (cin >> n >> k) {
        for (int i = 0; i < n; ++i) {
            cin >> data[i];
        }
        cout << k_th(data, n, k) << endl;
    }
    return 0;
}

計數排序 O(n)

按照計數排序思想給資料的值計數，再從資料的最大值往最小值遍歷，則總次數大於等於k的那個數為第k大，見程式碼一目瞭然。
優點：速度快且不用庫也程式碼量少，妥妥的O(n)
缺點：只適用於數值不大的情況，當然你用hashmap這類庫計數的話就沒這問題了。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 1e5 + 5;
const int maxVal = 1e5 + 5; //O(n) 適用於資料值不大的情況

int k_th(int *data, int n, int k) {
    int mmin = data[0], mmax = data[0];
    int times[maxVal];
    memset(times,0,sizeof(times));

    for (int i = 0; i < n; ++i) {
        mmin = min(mmin, data[i]);
        mmax = max(mmax, data[i]);
        times[data[i]]++;
    }

    int cnt = 0;
    for (int i = mmax; i >= mmin; --i) {
        cnt += times[i];
        if (cnt >= k) { // >= 是因為第k大的數可能有若干個，找第一個
            return i;
        }
        //反過來遍歷則為第k小
        //每次輸出times[i]次i，注意下邊界就出了有序前k大
    }
    return -1;
}

int main() {
    // freopen("in.txt","r",stdin);
    // freopen("out.txt","w",stdout);
    int n, k, data[maxn];
    std::ios::sync_with_stdio(false);
    while (cin >> n >> k) {
        for (int i = 0; i < n; ++i) {
            cin >> data[i];
        }
        cout<< k_th(data, n, k) <<endl;
    }
    return 0;
}

二分 O(nlogn)

假設第K大的數字是val，那麼val肯定在一個數字區間裡，我們叫 [l,r] ，我們就二分這個區間和val。
最開始l=所有數的最小值，r=最大值，假設當前值是mid，如果所有資料中大於等於mid的數字至少k個，說明當前數值可能是答案（若mid存在的情況則將區間調為[mid,r]，mid不存在的話就改為[mid+1,r]），否則mid偏大，在[l,mid-1]裡查詢；二分不會的可見這篇文章。
二分本身是需要有序的，但我們二分的是答案值，int數字本身就有排序效果。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 1e5 + 5;
const int maxVal = 1e5 + 5;

bool ok(int *data, int n, int k, int mid) {
    int cnt = 0;
    for (int i = 0; i < n; ++i) {
        if (data[i] >= mid) cnt++;
    }
    return cnt >= k;
}
int k_th(int *data, int n, int k) {
    int mmin = data[0], mmax = data[0];
    bool vis[maxVal];
    memset(vis, false, sizeof(vis));

    for (int i = 0; i < n; ++i) {
        mmin = min(mmin, data[i]);
        mmax = max(mmax, data[i]);
        vis[data[i]] = true;
    }

    int l = mmin, r = mmax;
    while (l < r) {
        int mid = (l + r + 1) / 2;
        if (ok(data, n, k, mid)) {
            if (!vis[mid]) l = mid + 1;
            else l = mid;
        } else {
            r = mid - 1;
        }
    }
    return l;
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    int n, k, data[maxn];
    std::ios::sync_with_stdio(false);
    while (cin >> n >> k) {
        for (int i = 0; i < n; ++i) {
            cin >> data[i];
        }
        cout << k_th(data, n, k) << endl;
    }
    return 0;
}

暴力式選擇/氣泡排序 O(kn)

特慢做法：排序k個，每次遍歷n個元素，O(k*n)

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 1e5 + 5;

int k_th(int *data, int n, int k) {
    for (int i = 0; i < k; ++i) {
        for (int j = 0; j < n - i - 1; ++j) {
            if (data[j] > data[j + 1]) {
                swap(data[j], data[j + 1]);
            }
        }
    }
    return data[n-k];
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    int n, k, data[maxn];
    std::ios::sync_with_stdio(false);
    while (cin >> n >> k) {
        for (int i = 0; i < n; ++i) {
            cin >> data[i];
        }
        cout << k_th(data, n, k) << endl;
    }
    return 0;
}

真暴力排序O(nlogn)

排完取 data[k]，這麼暴力就不說了。

資料生成程式碼

生成10組資料，每組一個n（範圍：[a_n,b_n]），然後n個數 [a,b]。

#include <cstdio>
#include <cmath>
#include <cstdlib>
using namespace std;
int rand_ab(int a, int b) { //[a,b]
    return a + rand() % (b + 1 - a);
}
void make(){    
    int a_n = 10000, b_n = 100000;
    int a = 1, b = 10000;
    for (int i = 0; i < 10; ++i) {
        int n = rand_ab(a_n, b_n);
        printf("%d ", n);
        int a_k = 1, b_k = n;
        printf("%d\n", rand_ab(a_k,b_k));
        printf("%d", rand_ab(a, b));
        for (int i = 1; i < n; ++i) {
            printf(" %d", rand_ab(a, b));
        }
        printf("\n");
    }
}
int main() {
    // freopen("out.txt","w",stdout);
    make();
    return 0;
}

相關推薦

第K大/Top K及其簡單實現

見網上第K大多數只給思路，沒給實現，我就來填坑了。 update 2017-09-23 有同學反饋說面試遇到這個題，博文給了助攻，哈預料之中。 Top K 和第K大基本等價，以下我們以第K大為例且假設第K大一定存在，Top K 可以在第k大基礎上稍微

基於快排實現，在N個亂序的陣列中找第K大的數（Java實現）

類似於快速排序，執行一次快速排序之後，每次只選擇一部分繼續執行快速排序，直到找到第K大個元素為止，這個元素在陣列位置後面的元素即為所求。 時間複雜度：O（n） 利用快排的思想，從陣列arr中隨機找出一個元素X，把陣列分成兩部分arr_a和arr_b。 arr_a中的元素比x大，arr_b中的元素比x小。 這

尋找最大的K個數(TOP K演算法)

前言： 問題描述： 有很多個無序的數，怎麼從中選出其中最大的若干數呢？ 這個問題中的很多可以是幾個數也可以使成百上億的數，針對此問題我們有以下解法： 解法一： 咱們先簡單的理解，要求一個序列中最小的k個數，按照慣有的思維方式，很簡單，先對這個序列從小到大排序，然後輸出前面

二叉堆 binary heap (2) 利用小根堆求最大 top k

使操作被快速執行的性質是堆序(heap order)性. 由於我們想要快速地找出最小元，因此最小元應該在根上. 類似的，可以宣告一個max堆，找到和刪除最大元      在一個堆中，對於每一個節點X，X的parent中的關鍵字<=X中的關鍵字, 根節點除外(它沒有p

N個降序陣列，找到最大的K個數TOP K

轉載至：http://www.cnblogs.com/ywl925/p/3794852.html 假定有20個有序陣列，每個陣列有500個數字，降序排列，數字型別32位uint數值，現在需要取出這10000個數字中最大的500個，怎麼做？ 解決方法 這裡其實有很多解

最大熵模型及其python實現

剛開始學習最大熵模型的時候，自以為書中的推導都看明白了。等到自己實現時才發現問題多多。因此，這篇部落格將把重點放在python程式的解讀上，為什麼說是解讀呢，因為這個程式不是我寫的（輕點噴~~），這個程式參考了網上的一篇部落格，地址：http://blog.cs

哈夫曼壓縮原理及其簡單實現

1、原理 首先要了解一下哈夫曼樹即最優二叉樹的概念，就是給每個葉子節點一個權值，構建一顆二叉樹，使得權值乘以葉子節點到跟節點的和值最小，那麼這棵樹就       是最優二叉樹。下面就是建立一棵二叉樹的過程，葉子節點裡的值就是其權值    現在來看一看這個最優二叉樹

C++智慧指標及其簡單實現

使用智慧指標的緣由 　　1. 考慮下邊的簡單程式碼： 1 int main() 2 { 3 int *ptr = new int(0); 4 return 0; 5 }  　　就如上邊程式，我們有可能一不小心就忘了釋放掉已不再使用的記憶體，從而導致

IOC介紹及其簡單實現

package cn.test.ioc; public interface HelloIF { String sayHello(); } 　　傳統實現： package cn.test.ioc; import java.util.Calendar; /** * 傳統實現(非IOC方式)

資料流中的第k大元素的golang實現

設計一個找到資料流中第K大元素的類（class）。注意是排序後的第K大元素，不是第K個不同的元素。 你的 KthLargest 類需要一個同時接收整數 k 和整數陣列nums 的構造器，它包含資料流中的初始元素。每次呼叫 KthLargest.add，返回當前資料流中第K大的元素。 int k =

c語言實現求元素的第k大

求n個元素序列中第k大的元素。 #include<stdio.h> #include<stdlib.h> #define MAX 100 int second(int t[],int left,int right,int p) { int

程式設計師程式設計藝術-----第三章續-----Top K演算法問題的實現

                     程式設計師程式設計藝術：第三章續、Top K演算法問題的實現前奏    在上一篇文章，程式設計師面試題狂想曲：第三章、尋找最小的k個數中，後來為了論證類似快速排序中partition的方法在最壞情況下，能在O（N）的時間複雜度內找到最小的k個數，而前前後後update

【C++實現】第k大元素 時間複雜度為O(n)，空間複雜度為O(1)

解題思路： 二基準快速排序，在排序時判斷每次找到的標記點下標 p 與 n-k 的大小，若小於n-k，則只需在p的右側繼續遞迴，若大於 p 則只需在p 的左側遞迴，直至 p 與 n-k 相等 vs可執行程式碼 #include<ctime> #includ

找出陣列中第k大的數（時間複雜度分析、C++程式碼實現）. TopK in array. ( leetcode

找出陣列中第k大的數. TopK in array. ( leetcode - 215 ) 最近面試過程中遇到的一個題目，也是大資料時代常見的題目，就來總結一下。 面試題目： 1、10億數中，找出最大的100個數。用你能想到的最優的時間和空間效率。 2

java 實現從無序陣列中 找出第k大的數, 無序陣列充許有重複元素

要求找出第幾名的元素是什麼（找出B[i]的值）？ 找出第k名的元素的值。          先從A中隨機一個下標index1， 然後進行一趟快速排序等到新陣列A1，排完了就知道index1對應的元素在A1中的新下標index2. 如果k等於index2,則A1[index2]就是要找的值。 如果 k小於in

劍指Offer/滴滴2018校招筆試題-找出陣列中第K大元素-雙路快排實現

程式設計題例項 滴滴2018校招筆試題程式設計題2： 找出陣列中第K大的元素 輸入 45，66，58，22 2 輸出 45 程式設計原理 這道題與

Java實現O(log(n+m))兩個有序陣列中第K大元素或中位數

假設有兩個從小到大的有序陣列A和B，他們的元素個數為N和M，那麼怎麼求得其第K大元素呢？同理，求其中位數就是當N+M為奇數求其第(N+M+1)/2大元素，為偶數時求(N+M)/2和(N+M+2)/2大元素的平均值。 那麼我們怎麼才能求得第K大元素呢？ 分別取兩個陣列中間索

二叉搜尋樹中的第K大的節點 java實現

給定一顆二叉搜尋樹，請找出其中的第k大的結點。例如， 5 / \ 3 7 /\ /\ 2 4 6 8 中，按結點數值大小順序第三個結點的值為4。解題思路：因為這是一顆二叉搜尋樹，返回的第K個節點其實就是二叉樹按中序遍歷的第K個節點。思路一：按中序遍歷順序，將節點一個一個存在LinkedList中，存完之後，取

The kth great number multiset應用（找第k大值）

for begin urn mes etc when ++ multi size The kth great number Xiao Ming and Xiao Bao are playing a simple Numbers game. In a round Xiao

[poj 2104]主席樹+靜態區間第k大

include end 區間 得到 name int 題目 tar tdi 題目鏈接：http://poj.org/problem?id=2104 主席樹入門題目，主席樹其實就是可持久化權值線段樹，rt[i]維護了前i個數中第i大（小）的數出現次數的信息，通過查詢兩棵樹的差