c++实现堆

堆数据结构是一种数组对象，它可以被视为一棵完全二叉树结构。堆结构的二叉树存储是
最大堆：每个父节点的都大于孩子节点。
最小堆：每个父节点的都小于孩子节点。
比如有一个数组

那么我们就相当于创建了一颗完全二叉树

如果要建最大堆，则如下图所示

如果要建最小堆，则如下图所示

代码实现：

#pragma once
#include <vector>
#include <iostream>
#include<cassert>
using namespace std;

template <class T>
class Less
{
public:
    bool operator()(const T& a, const T& b)
    {
        return a < b;
    }
};
template <class T>
class Greater
{
public:
    bool operator()(const T& a, const T& b)
    {
        return a > b;
    }
};
template <class T,class Compare = Less<T>>
class Heap
{
public:
    Heap(const T* a, size_t size)
    {
        _a.reserve(size);
        for (size_t i = 0; i < size; i++)
        {
            _a.push_back(a[i]);
        }
        for (int j = (_a.size() - 2) / 2; j >= 0; j--)
        {
            _AdjustDown(j);
        }
    }
    void Push(const T& x)
    {
        _a.push_back(x);
        _AdjustUp(_a.size()-1);
    }
    void Pop()
    {
        assert(!_a.empty());
        swap(_a[0], _a[_a.size() - 1]);
        _a.pop_back();
        _AdjustDown(0);
    }
    T& GetTop()
    {
        assert(!_a.empty());
        return _a[0];
    }
    bool Empty()
    {
        return _a.empty();
    }
    size_t Size()
    {
        return _a.size();
    }
protected:
    //将根节点向下调整
    void _AdjustDown(int root)
    {
        assert(!_a.empty());
        size_t parent = root;
        size_t child = parent * 2 + 1;
        while (child<_a.size())
        {
            Compare com;
            if (child+1<_a.size() && com(_a[child+1] , _a[child]))
            {
                ++child;
            }
            if (com(_a[child] , _a[parent]) && child<_a.size())
            {
                swap(_a[parent], _a[child]);
                parent = child;
                child = parent * 2 + 1;
            }
            else
            {
                return;
            }
        }
    }
    //一个节点向上调整
    void _AdjustUp(size_t child)
    {
        assert(!_a.empty());
        while (child > 0)
        {
            Compare com;
            size_t parent = (child - 1) / 2;
            if (com(_a[child] , _a[parent]))
            {
                swap(_a[parent], _a[child]);
                child = parent;
            }
            else
            {
                return;
            }
        }
    }
protected:
    vector<T> _a;
};
void TestHeap()
{
    int a[] = { 3,8,12,2,19,11,14,13,15,10};
    Heap<int> a1(a, 10);
    a1.Push(100);
    a1.Pop();
}

#include "Heap.h"
int main()
{
    TestHeap();
    return 0;
}