寫在前面

最近漸漸愛上寫部落格，覺得每天學到的知識需要保鮮，寫的原始碼也能及時與大家分享，接下來進入正題。

最大堆（最小堆）

最大堆（最小堆）是非常重要的資料結構，公司面試時經常會被問到，在這裡，我不會詳細介紹它的原理，而是介紹它的適用場景以及兩種寫法，對原理不瞭解的可以檢視：
https://en.wikipedia.org/wiki/Heap_%28data_structure%29
假設有10萬個數，讓你求最小的k個數，你會怎麼做？

• 先排序，然後取前k個數，時間複雜度O(nlogn)
• 維護k個數的最大堆，時間複雜度O(nlogk)

考慮第一種方式，當記憶體有限時，沒法一次載入10萬個數，排序不可取，而第二種方式，每次只載入一個數，最多儲存k個數（最大堆），當堆滿時，通過比較當前數與堆頂值，若堆頂值大，則刪除堆頂，插入當前數，反之，則不做任何操作，也就是說，最大堆一直儲存著當前載入數裡最小的k個數。

最大堆C++實現原始碼

這裡給出了兩種寫法，最小堆同理，值得注意的是，最大堆（最小堆）一定是一顆完全二叉樹，可以用陣列表示，如有錯誤還望指正。

• 非遞迴寫法

#include <vector>
#include <cassert>
using namespace std;
class MaxHeap
{
private:
    vector<int> heap;
    int size;
public:
    void make_heap(vector<int>& nums, int s)
    {
        //構建堆
 

        heap.assign(nums.begin(), nums.end());
        size =  s;
        for (int i = size / 2 - 1; i >= 0; i--)
            down(i);
    }
    void push(int num)
    {
        //插入元素
        heap.push_back(num);
        size++;
        up(size - 1);
    }
    int pop()
    {
        //刪除元素
        assert(size > 0
 
);
        int result = heap[0];
        heap[0] = heap[size - 1];
        heap.pop_back();
        size--;
        down(0);
        return result;
    }
    void down(int index)
    {
        assert(index >= 0);
        int temp = heap[index];
        index = index * 2 + 1;
        while (index < size)
        {
            if (index + 1 < size && heap[index] < heap[index + 1]) index++;
            if (heap[index] < temp) break;
            else
            {
                heap[(index - 1) / 2] = heap[index];
                index = index * 2 + 1;
            }
        }
        heap[(index - 1) / 2] = temp;
    }
    void up(int index)
    {
        assert(index < size);
        int temp = heap[index];
        while (index > 0 && temp > heap[(index - 1) / 2])
        {
            heap[index] = heap[(index - 1) / 2];
            index = (index - 1) / 2;
        }
        heap[index] = temp;
    }
};

• 遞迴寫法

void down(int index)
{
    assert(index >= 0);
    int temp = index;
    index = index * 2 + 1;
    if (index >= size) return;
    if (index + 1 < size && heap[index] < heap[index + 1]) index++;
    if (heap[index] < heap[temp]) return;
    else
    { 
        swap(heap[index], heap[temp]);
        down(index);
    }
}
void up(int index)
{
    assert(index < size);
    if (index == 0) return; 
    if (heap[index] < heap[(index - 1) / 2]) return;
    else 
    {
        swap(heap[index], heap[(index - 1) / 2]);
        up((index - 1) / 2);
    }
}

很明顯，遞迴寫法兩元素交換次數比非遞迴寫法多。