Top K问题

Top K问题：前K个最大的数

参考

1. 海量数据处理的 Top K算法(问题) 小顶堆实现
2. 《算法导论》读书笔记之第6章 堆排序
3. 寻找最小的k个数

问题描述

输入N个整数， N很大， 求出其中的前K个最大的数,K很小，一般在10以内。

由于输数据很大，但只求前K个最大的值，所以对所有输入数据的保存和排序是不可取的。

1 解法一：最小堆

利用最小堆的性质，每个非叶结点的数值，都小于等于其孩子节点的数值。利用含有K个节点的最小堆，保存K个目前的最大值。

每次接受新的数据输入时，先与根节点比较。若不大于根节点，则舍弃；否则用新数值替换根节点数值，并进行最小堆的调整。

1.1 最小堆复习

@算法导论

1.1.1 堆化数组

用数组存储堆，

若数组下标从1开始，则parent(i) = i/2, left(i) = i*2, right(i) = i*2+1

若数组下标从0开始，则parent(i) = i/2, left(i) = i*2 + 1, right(i)=i*2+2

最小堆的性质：

• 除了根结点以外，对于所有节点i，有A[parent(i)] \le A[i]
• 含有n个元素的节点高度是ceil(lgn)
• 叶子节点的下标是n/2+1,…,n（下标从1开始）；n/2,…,n-1（下标从0开始）

---

以下讨论的都是下标从0开始的情况

---

1.1.2 维护堆

给定一个节点i，保证以i为根的子树满足堆性质，是自顶向下的过程

递归与非递归版的维护堆代码：

// 维护最小堆，递归, 调整以i为根的子树
void adjust_min_heap_recursive(int *a, int n, int i){
    int left = i * 2 + 1;  // 节点i的左孩子编号
    int right = left + 1; // 节点i的右孩子编号
    int smallest = i; // 默认最小是父节点
    if(left < n && a[left] < a[smallest]) // 找到i与其左右孩子中最小值的编号
        smallest = left;
    if(right < n && a[right] < a[smallest])
        smallest = right;
    if(smallest != i){ // 若最小值不是父节点
        swap(a[smallest], a[i]);
        adjust_min_heap_recursive(a, n, smallest); // 递归，继续自顶向下维护
    }
}

// 维护最小堆，非递归, 调整以i为根的子树
void adjust_min_heap(int *a, int n, int i){
    int left, right, smallest = i;
    while(1){
        left = 2 * i + 1;
        right = left + 1;
        if(left < n && a[left] < a[smallest])
            smallest = left;
        if(right < n && a[right] < a[smallest])
            smallest = right;
        if(smallest != i){
            swap(a[i], a[smallest]);
            i = smallest;
        } else {
            break;
        }
    }
}

1.1.3 建堆

建堆时，调用维护堆过程，是自底向上的过程，从数组的最后一个非叶结点(n/2-1)开始调整。

建堆代码：

// 建堆，堆化数组
void build_min_heap(int *a, int n){
    for(int i = n/2 - 1; i >= 0; --i){
        adjust_min_heap_recursive(a, n, i);
        // adjust_min_heap(a, n, i);
    }
}

1.1.4 堆排序（与Top K问题无关）

顺便复习一下堆排序

堆排序的流程是：

• 建最大堆，将输入数组a[1..N]转化为最小堆，使得最小值在堆顶，也就是a[0]；
• 每次不断将最大值提取出来，放置到数组的末尾，再将原数组末尾的值挪到堆顶，最大堆的size-1，并对剩下的对元素进行调整。

1.1.5 测试程序

#include <iostream>
#include <algorithm>
#include <cstdlib>
using namespace std;
// 数组下标从0开始

void print_array(int *a, int n){
    for(int i = 0; i < n; ++i){
        cout << a[i] << " ";
    }
    cout << endl;
}

// 维护最小堆，递归, 调整以i为根的子树，自顶向下
void adjust_min_heap_recursive(int *a, int n, int i){
    int left = i * 2 + 1;  // 节点i的左孩子编号
    int right = left + 1; // 节点i的右孩子编号
    int smallest = i; // 默认最小是父节点
    if(left < n && a[left] < a[smallest]) // 找到i与其左右孩子中最小值的编号
        smallest = left;
    if(right < n && a[right] < a[smallest])
        smallest = right;
    if(smallest != i){ // 若最小值不是父节点
        swap(a[smallest], a[i]);
        adjust_min_heap_recursive(a, n, smallest); // 递归，继续自顶向下维护
    }
}

// 建堆，堆化数组，自底向上
void build_min_heap(int *a, int n){
    for(int i = n/2 - 1; i >= 0; --i){
        adjust_min_heap_recursive(a, n, i);
        // adjust_min_heap(a, n, i);
    }
}

int main(){
    const int N = 10;
    int a[N];
    for(int i = 0; i < N; ++i){
        a[i] = rand() % 20;
    }
    cout << "堆化前数组：";
    print_array(a, N);

    build_min_heap(a, N);

    cout << "堆化后数组：";
    print_array(a, N);

    return 0;
}

1.2 Top K max 最小堆解法

时间复杂度O（nlogK）=O（n），空间复杂度O（K）=O（1）

前面第1节介绍的方法再提一遍。

利用含有K个节点的最小堆，保存K个目前的最大值。

每次接受新的数据输入时，先与根节点比较。若不大于根节点，则舍弃；否则用新数值替换当前的最小值，即根节点，并进行最小堆的调整。

#include <iostream>
#include <algorithm>
#include <fstream>
#include <cstdlib>
#include <cstdio>
using namespace std;

// 数组下标从0开始

void print_array(int *a, int n){
    for(int i = 0; i < n; ++i){
        cout << a[i] << " ";
    }
    cout << endl;
}


void write_rand_num(int n, int range)
{
    ofstream out("data.txt");
    if(out.is_open()){
        for(int i = 0; i < n; ++i){
            out << rand() % range << endl;
        }
        out.close();
    }
}

// 维护最小堆，递归, 调整以i为根的子树，自顶向下
// 时间复杂度O（logK），空间复杂度O(1)
void adjust_min_heap_recursive(int *a, const int n, int i){
    int left = i * 2 + 1;  // 节点i的左孩子编号
    int right = left + 1; // 节点i的右孩子编号
    int smallest = i; // 默认最小是父节点
    if(left < n && a[left] < a[smallest]) // 找到i与其左右孩子中最小值的编号
        smallest = left;
    if(right < n && a[right] < a[smallest])
        smallest = right;
    if(smallest != i){ // 若最小值不是父节点
        swap(a[smallest], a[i]);
        adjust_min_heap_recursive(a, n, smallest); // 递归，继续自顶向下维护
    }
}

// 建堆，堆化数组，自底向上
// 时间复杂度O（n）*O（logK） = O（nlogK），空间复杂度O(K)(建立的大小为K的堆化数组)
void build_min_heap(int *a, const int n){
    for(int i = n/2 - 1; i >= 0; --i){
        adjust_min_heap_recursive(a, n, i);
        // adjust_min_heap(a, n, i);
    }
}

int main(){

    int n = 100; // N很大
    // write_rand_num(n, 50); // 第一次运行，产生随机数据，写入data.txt

    // 第二次运行，从data.txt读数据
    const int K = 10; // K很小
    int *a = new int[K], temp;

    freopen("data.txt", "r", stdin);

    // 先读K个
    for(int i = 0; i < K; ++i){
        cin >> a[i];
    }
    // 堆化数组，建立最小堆
    build_min_heap(a, K);
    cout << "初始最小堆：";
    print_array(a, K);

    // 继续读剩余的n-K个
    for(int i = K; i < n; ++i){
        cin >> temp;
        if(temp > a[0]){
            a[0] = temp;
            adjust_min_heap_recursive(a, n, 0); // 向下调整
        }
    }

    cout << "最终最小堆：";
    print_array(a, K);

    fclose(stdin);
    return 0;
}

注意：必须分两次运行才可以，而且这样写实在太丑，目前猜测原因是两次写/读的流不同导致数据不同步。

另：是时候来个C/C++ IO专题了。

2 解法二：选择/交换排序

使用选择/交换排序，每轮对K个元素进行排序，流程如下：

1. 存入前K个数，这K个数是当前最大的K个数。O（k）
2. 对K个数，利用选择或交换排序找到K个元素中的最小值kmin。O（k）
3. 继续遍历剩余n-k个数，设每次遍历到的新元素为x，
   1) 若x>kmin, 则用x替换kmax，并回到第2步，找出k个元素中的最小值kmin’
   2) 否则继续遍历下个元素。

时间复杂度O（n）*O（k） = O（nk）

使用快速排序，实现如下：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
using namespace std;

void print_array(int *a, int n){
    for(int i = 0; i < n; ++i){
        cout << a[i] << " ";
    }
    cout << endl;
}

// 划分，第一个数为基准
int partition(int *a, int from, int to)
{
    int i = from;
    int j = to + 1;
    int pivot = a[from];
    while(true){
        // 从前向后，找到第1个比基准大的数，i指向该数
        while(i < to && a[++i] < pivot);
        // 从后向前，找到第1个比基准小的数，j指向该数
        while(j > from && a[--j] > pivot);
        if(i >= j) break;
        swap(a[i], a[j]);
    }
    swap(a[from], a[j]);
    return j;
}

void quick_sort(int *a, int from, int to){
    if(from < to)
    {
        int p = partition(a, from, to);
        quick_sort(a, from, p - 1);
        quick_sort(a, p + 1, to);
    }
}

int main(){
    int n = 100;
    int K = 10;
    freopen("data.txt", "r", stdin);

    int *a = new int[K];
    int i, temp;

    for(i = 0; i < K; ++i){
        cin >> a[i];
    }
    quick_sort(a, 0, K-1);

    cout << "初始Top K max数组：";
    print_array(a, K);

    for(i = K; i < n; ++i){
        cin >> temp;
        if(temp > a[0]){
            a[0] = temp;
            quick_sort(a, 0, K-1);
        }
    }

    cout << "最终Top K max数组：";
    print_array(a, K);

    fclose(stdin);
    return 0;
}

3 解法三：快速选择算法

《数据结构与算法分析–c语言描述》书中，第7章第7.7.6节，阐述了一种在平均情况下，时间复杂度为 O（N） 的快速选择算法，用于选择第K小的元素，将算法改成选择第k大的，流程如下：

（注：不知道为什么平均情况下时间复杂度为O（N））

1. 选取S中一个元素作为枢纽元v，将集合S-{v}分割成S1和S2，就像快速排序那样
2. 如果k <= |S2|，那么第k个最大元素必然在S2中。在这种情况下，QuickSelect(S2, K)，继续排序S2部分，最终数组后K个为所求的最大的K个数。
3. 如果k = 1 + |S2|，那么枢纽元素就是第k个最大元素，则从第K到n为最大的K个数
4. 否则，k > |S2| + 1，这第K个最大元素就在S1中，即在S1中的后（k - |S1| - 1）个最小元素，递归调用并返回QuickSelect(S1, k - |S1| - 1)。

将该算法转换成选择前K大的也不难，就是每次排序的时候比快排多了判断条件；该算法需要保存所有的数据。

也可以每次读2*K个数据，然后每次排序后，最后K个是最大的K个数，最后再归并？这样复杂度就变成了O(nlogn).

所以快速选择算法只能在n不太大的时候用了。

还有很多解决方案，未完待续。。。