【數據結構】找出N個數據中最大的前k個數據（利用堆排序）

咱們舉例，倘若從10000萬個數裏選出前100個最大的數據。

首先咱們先分析：既然要選出前100個最大的數據，咱們就創建一個大小爲100的堆（建堆時就按找最大堆的規則創建，即每個根節點都大於它的子女節點），而後再將後面的剩餘數據若符合要求就插入堆中，不符合就直接丟棄該數據。

那咱們如今考慮：肯定是該選擇最大堆的數據結構仍是最小堆的數據結構呢。

分析一下：

若選用最大堆的話，堆頂是堆的最大值，咱們考慮既然要選出從10000萬個數裏選出前100個最大的數據，咱們在建堆的時候，已經考慮了最大堆的特性，那這樣的話最大的數據必然在它頂端。倘若真不巧，我開始的前100個數據中已經有這10000個數據中的最大值了，那對於我後面剩餘的10000-100的元素再想入堆是否是入不進去了！！！因此，選用最大堆從10000萬個數裏選出前100個最大的數據只能找出一個，而不是100個。

那若是選用最小堆的數據結構來解決，最頂端是最小值，再次遇到比它大的值，就能夠入堆，入堆後從新調整堆，將小的值pass掉。這樣咱們就能夠選出最大的前K個數據了。言外之意，倘若咱們要找出N個數據中最小的前k個數據，就要用最大堆了。

代碼實現(對於最大堆最小堆的代碼，如有不明白的地方，你們能夠查看個人博客http://10740184.blog.51cto.com/10730184/1767076)：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

#include<assert.h>

void AdjustDown(int* a, int parent, int size)
{
    int child = 2 * parent + 1;
    while (child < size)
    {
        if (child + 1 < size && a[child] > a[child + 1])
        {
            child++;
        }
        if (a[parent]>a[child])
        {
            swap(a[parent], a[child]);
            parent = child;
            child = 2 * parent + 1;
        }
        else
        {
            break;
        }
    }
}


void Print(int* a, int size)
{
    cout << "前k個最大的數據：" << endl;
    for (int i = 0; i < size; i++)
    {
        cout << a[i] << "  ";
    }
    cout << endl;
}


int* HeapSet(int*a,int N,int K)
{
    assert(a);
    assert(K > 0);
    int* arr = new int[K];
    //將前K個數據保存
    for (int i = 0; i < K; i++)
    {
        arr[i] = a[i];
    }

    //建堆
    for (int i = (K-2)/2; i >=0; i--)
    {
        AdjustDown(arr,i,K);
    } 

    //對剩餘的N-K個元素比較大小
    for (int i = K; i < N; i++)
    {
        if (arr[0]<a[i])
        {
            arr[0] = a[i];
            AdjustDown(arr, 0, K);
        }
    }

    return arr;
    delete[] arr;
}


void Test()
{
    int arr[] = { 12, 2, 10, 4, 6, 8, 54, 67, 25, 178 };
    int k = 5;
    int* ret = HeapSet(arr, sizeof(arr) / sizeof(arr[0]), k);
    Print(ret, k); 
}


int main()
{
    Test();
    system("pause");
    return 0;
}

由此能夠看出，時間複雜度爲：Ｋ＋（Ｋ-2）/２*lgn＋（Ｎ－Ｋ）*lgn  --＞  O(N)

空間複雜度爲：K-->O(1)。