堆資料結構是一種陣列物件，它可以被看做是一棵完全二叉樹。

堆的二叉樹儲存有兩種方式：
1.最大堆：每個父節點的值都大於孩子節點
2.最小堆：每個父節點的值都小於小子節點
如上圖所示就是一個最小堆。

關於堆，其實說到底就是兩種演算法，一種是向下調整演算法，一種是向上調整演算法。我們先結合圖來分析一下這兩種演算法。
就拿上圖來說，上圖是一個小堆，接下來比如說我們要往裡插入一個9，那麼因為堆的底層實際上是一個數組物件，實際上就是一個vector，那麼插入的9，就是在如圖的位置

但因為這是個最小堆，所以要對9進行向上調整，把9和它的父親的值16比，因為9比16小，那麼就交換9和16的位置；再拿9和11比，9比11小，交換9和11的位置；9和10比，9比10小，交換9和10的位置。直到交換到9比它的父節點大了或是9已經交換到根節點了就停止，上圖在進行向上調整後的結果如下圖。

在進行向上調整的過程中，只會對插入位置的祖先這一條線產生影響，對堆的其他線並不會產生影響。向下調整也是如此，比如我們在進行刪除操作的時候，Pop掉的都是堆頂位置Top的值，也就是root位置的值（如向上調整好的圖就是Pop 9），我們一般採用的方法就是，先交換9和16的位置，再對該堆進行一個Pop操作（因為底層是一個vector，Pop操作直接刪除尾部元素），這樣一來9就刪除了

然而Top位置的值此時是16，所以就要對16進行向下調整，將16的兩個孩子的值進行比較，這裡因為是小堆，所以就選小的那個（大堆就選大的那個），所以就將16和10 的位置進行交換，以此類推，接著就是16和11交換，直到孩子都比16的值大，或是16已經是葉子節點了就停止。調整好的就是一開始的那個小堆

核心的演算法我們已經掌握了，接下來就是程式碼的實現了。因為應用的過程中，可能既會用到大堆也會用到小堆，同時寫一個大堆和一個小堆會產生程式碼重複，所以我們採用以下的方法來構建堆物件，這裡用到仿函式。

#pragma once

#include <iostream>
#include <vector>
using namespace std;
#include <assert.h>

template <class T>
struct Less//小堆
{
    bool operator()(const T& left, const
 
 T& right)
    {
        return left < right;
    }
};

template <class T>
struct Greater//大堆
{
    bool operator()(const T& left, const T& right)
    {
        return left > right;
    }
};

template <class T,class Compare=Greater<T>>//預設構建大堆
class Heap
{
public:
    Heap()
    {}

    Heap(const T* a, size_t size)
    {
        assert(a);
        _a.reserve(size);
        for (size_t i = 0; i < size; ++i)
        {
            _a.push_back(a[i]);
        }
        for (int i = (size - 2) / 2; i >= 0; i--)
        //從第一個非葉子節點開始調整，此處i必須給int，給size_t會死迴圈
        {
            _Adjustdown(i);
        }
    }

    void Pushback(const T& n)//
    {
        _a.push_back(n);
        size_t child = _a.size() - 1;
        _Adjustup(child);
    }

    void Pop()
    {
        assert(!_a.empty());
        swap(_a[0], _a[_a.size() - 1]);
        _a.pop_back();
        _Adjustdown(0);
    }

    size_t Size()
    {
        return _a.size();
    }

    bool Empty()
    {
        return _a.empty();
    }

    const T& Top()
    {
        return _a[0];
    }
protected:
    void _Adjustdown(size_t root)//向下調整
    {
        size_t child = root * 2 + 1;
        while (child<_a.size())
        {
            Compare com;
            if ((child + 1)<_a.size() && com(_a[child+1],_a[child]))
            /*對括號內左右物件進行比較，若是Less，則當左值小於右值時為真
                                        若是Greater，則當左值大於右值時為真*/
            {
                ++child;
            }
            if (com(_a[child] , _a[root]))
            {
                swap(_a[child], _a[root]);
                root = child;
                child = root * 2 + 1;
            }
            else
            {
                break;
            }
        }
    }

    void _Adjustup(int child)//向上調整
    {
        int parent = (child - 1) / 2;
        while (parent >= 0)
        {
            Compare com;
            if (com(_a[child] , _a[parent]))
            {
                swap(_a[parent], _a[child]);
                child = parent;
                parent = (child - 1) / 2;
            }
            else
            {
                break;
            }
        }
    }
protected:
    vector<T> _a;
};

void TestHeap()
{
    int a[] = { 10, 11, 13, 12, 16, 18, 15, 17, 14, 19 };
    Heap<int> hp(a, sizeof(a) / sizeof(a[0]));
    hp.Pushback(20);
    hp.Pop();
}

堆的應用有很多，下面我們來看一下
一.優先順序佇列
優先順序佇列是不同於先進先出佇列的另一種佇列。每次從佇列中取出的是具有最高優先權的元素，這裡的最高優先權就可以理解為最大堆和最小堆的Top元素，通過上面實現的堆來實現優先順序佇列

template <class T,class Compare=Greater<T>>
class PriorityQueue
{
public:
    PriorityQueue()
    {}

    PriorityQueue(T* a, size_t n)
    {
        for (size_t i = 0; i < n; ++i)
        {
            _h.Pushback(a[i]);
        }
    }

    void Push(const T& x)
    {
        _h.Pushback(x);
    }

    void Pop()
    {
        _h.Pop();
    }

    size_t Size()
    {
        return _h.Size();
    }

    bool Empty()
    {
        return _h.Empty();
    }

    const T& Top()
    {
        return _h.Top();
    }
protected:
    Heap<T, Compare> _h;
};

void TestPriorityQueue()
{
    int a[] = { 10, 11, 13, 12, 16, 18, 15, 17, 14, 19 };
    PriorityQueue<int> q(a, 10);
    //q.Push(20);
    //q.Pop();
    size_t b = q.Top();
    cout << b << endl ;
}

這裡測試的時候我們預設實現大堆，測試結果如下

二.堆排序
我們使用堆排序肯定是因為它的時間複雜度O（N*lgN）相對於其他排序可能更好，
就升序而言，它的基本思想就是建好大堆後，將Top元素和最後一個數據元素交換，此時最後一個元素就是最大的數，再對剩下的數進行向下調整（不包括從Top位置交換下來的元素），把Top元素和倒數第二個元素進行交換，以此類推。降序同樣，建立小堆，思想類似。
升序的程式碼如下

void AdJustDown(int a[], size_t n, int root)
{
    if (a == NULL)
    {
        return;
    }

    int parent = root;
    int child = parent * 2 + 1;

    while (child < n)
    {
        if (child + 1 < n&&a[child] < a[child + 1])
        {
            child = child + 1;
        }
        if (a[parent] < a[child])
        {
            swap(a[parent], a[child]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

void HeapSort(int a[], size_t n)
{
    if (a == NULL)
    {
        return;
    }

    for (int i = (n - 2) / 2; i >= 0; --i)
    {
        AdJustDown(a, n, i);
    }

    int end = n - 1;
    for (size_t i = 0; i < n; ++i)
    {
        swap(a[0], a[end]);
        AdJustDown(a, end, 0);
        --end;
    }
}

void TestHeapSort()
{
    int a[] = { 10, 11, 13, 12, 16, 18, 15, 17, 14, 19 };
    HeapSort(a, sizeof(a) / sizeof(a[0]));
    for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        cout << a[i] << " ";
    }
}

測試結果如下

三.TopK問題
給一串陣列，要求找出這串陣列中最大的前K個數。這裡可以使用小堆來實現

template <class T,class Compare>
class TopK
{
public:
    TopK()
    {}

    TopK(int* a,int n,int k)
    //n表示陣列大小，k表示前k個
    {
        assert(k <= n);
        size_t i = 0;
        while (i < n)
        {
            //先將陣列的前K個數放入堆中
            if (i < k)
            {
                _minhp.Pushback(a[i]);
            }
            else
            {
                if (a[i]>_minhp.Top())
                //如果接下去的數比Top元素大，刪除Top元素，插入該元素
                {
                    _minhp.Pop();
                    _minhp.Pushback(a[i]);
                }
            }
            ++i;
        }

    }

protected:
    Heap<T ,Less<T>> _minhp;
};

void TestTopK()
{
    int a[] = { 10, 11, 13, 12, 16, 18, 15, 17, 14, 19 };
    TopK<int,Less<int>> top(a, sizeof(a) / sizeof(a[0]), 5);
}

測試的堆中結果如下

以上堆中的5個元素即是最大的前5個數。