数据结构：堆

堆：

堆实际上是一棵完全二叉树，其任何一非叶节点满足性质：
Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]或者Key[i]>=Key[2i+1]&&key>=key[2i+2]
即任何一非叶节点的关键字不大于或者不小于其左右孩子节点的关键字。
堆分为大顶堆和小顶堆，满足Key[i]>=Key[2i+1]&&key>=key[2i+2]称为大顶堆，满足 Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]称为小顶堆。由上述性质可知大顶堆的堆顶的关键字肯定是所有关键字中最大的，小顶堆的堆顶的关键字是所有关键字中最小的。

//这里用到了仿函数思想
//由于本人的编译集成环境没有greater，故根据库中less，模仿改写了一个greater
//仿函数的好处，可以提升代码的复用率，将相反的逻辑用仿函数标记出来即可
//采用的思想是向下调整算法
//并借助库中的vector来模拟堆的空间
#pragma once

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

template<class _Ty = void>
struct greater
    : public binary_function<_Ty, _Ty, bool>
{   // functor for operator<
    bool operator()(const _Ty& _Left, const _Ty& _Right) const
    {   // apply operator< to operands
        return (_Left > _Right);
    }
};
template<>
struct greater<void>
{   // transparent functor for operator<
    template<class _Ty1,
    class _Ty2>
        auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        -> decltype(static_cast<_Ty1&&>(_Left)
        > static_cast<_Ty2&&>(_Right))
    {   // transparently apply operator< to operands
            return (static_cast<_Ty1&&>(_Left)
                > static_cast<_Ty2&&>(_Right));
        }
};

template<class T, class Compare = less<T>>//仿函数,默认堆
class Heap//Heap<T,Compare>
{
public:
    Heap(){}
    Heap(const T* array, size_t size)
    {
        assert(array);

        for (size_t i = 0; i< size; ++i)
        {
            _vec.push_back(array[i]);
        }

        for (int i = _vec.size() / 2 - 1; i >= 0; --i)
        {
            _AdjustDown(_vec, i, _vec.size());
        }
    }

    Heap(const vector<T>& vec)
    {
        _vec.swap(vec);

        for (int i = _vec.size() / 2 - 1; i >= 0; --i)
        {
            _AdjustDown(_vec, i, _vec.size());
        }
    }
    //插入一个数据x到最小堆
    void Push(const T& x)
    {
        _vec.push_back(x);

        if (_vec.size() > 1)
        {
            _Adjust(_vec, _vec.size() - 1);
        }
    }
    //删除堆顶数据
    void Pop()
    {
        int size = _vec.size();
        assert(size > 0);

        swap(_vec[0], _vec[size - 1]);
        _vec.pop_back();

        if (_vec.size() > 1)
        {
            _AdjustDown(_vec, 0, _vec.size());
        }
    }
    //得到堆顶数据
    T& GetTop()
    {
        return _vec[0];
    }
    //将根节点向下调整
    void _AdjustDown(vector<T>& vec, int root, size_t size)
    {
        int child = root * 2 + 1;
        while (child < size)
        {
            // 2.child指向左右孩子中小的节点  
            if (child + 1 < size && Compare()(vec[child + 1], vec[child]))
            {
                ++child;
            }

            // 3.若child小于跟节点，则交换child和root节点，并继续向下调整  
            if (Compare()(vec[child], vec[root]))
            {
                swap(vec[child], vec[root]);
                root = child;
                child = root * 2 + 1;
            }

            else
            {
                break;
            }
        }
    }
    //一个节点向上调整
    void _Adjust(vector<T>& vec, int pos)
    {
        // 1.parent指向父节点  
        int child = pos;
        int parent = (child - 1) / 2;
        while (parent >= 0)
        {
            // 2.若child小于父节点，则交换父子节点，并继续向上调整，直到根节点  
            if (Compare()(vec[child], vec[parent]))
                //if (vec[child] < vec[parent])  
            {
                swap(vec[child], vec[parent]);
                child = parent;
                parent = (child - 1) / 2;
            }
            else
            {
                break;
            }
        }
    }
    //判空
    bool Empty()
    {
        return _vec.empty();
    }
    size_t Size()
    {
        return _vec.size();
    }
private:
    vector<T> _vec;
};

#include"Heap.h"

void TestHeap()  
{  

  //int array[10] = {9,1,3,5,6,7,8,0,2,4};  
  int array[10] = {10,16,18,12,11,13,15,17,14,19};  
  Heap<int, less<int>> heap1(array, 10);
  cout<< heap1.GetTop() << endl;
  heap1.Push(5);
  cout << heap1.GetTop() << endl;
  heap1.Pop();
  cout << heap1.GetTop() << endl;
} 
int main()
{
    TestHeap();
    system("pause");
    return 0;
}