二叉堆的实现

二叉堆是一种特殊的堆，二叉堆是完全二元树（二叉树）或者是近似完全二元树（二叉树）。

二叉堆有两种：最大堆和最小堆。

最大堆：父结点的键值总是大于或等于任何一个子结点的键值；

最小堆：父结点的键值总是小于或等于任何一个子节点的键值。

二叉堆一般都通过"数组"来实现。数组实现的二叉堆，父节点和子节点的位置存在一定的关系。我们将"二叉堆的第一个元素"放在数组索引0的位置。
假设"第一个元素"在数组中的索引为 0 的话，则父节点和子节点的位置关系如下： 
1、索引为i的左孩子的索引是 (2*i+1); 
2、索引为i的左孩子的索引是 (2*i+2); 
3、索引为i的父结点的索引是 floor((i-1)/2);

 

二叉堆这种有序队列如何入队呢？

假设要在这个二叉堆里入队一个单元，只要在数组末尾加入这个元素，然后把这个元素往上挪，直到挪不动，经过了这种复杂度为Ο(logn)的操作，二叉堆性质没有变化。

那如何出队呢？

我们习惯将二叉堆画成树的形式，但本质上还是用数组实现的。

具体代码如下：

#include <vector>
#include <iostream>
using namespace std;

template <typename T>
class MinHeap
{
public:
    vector<T> m_array;
    int m_size;//总容量
private:
    //最小堆的向下调整算法
    void FilterDown(int start, int end);
    //最小堆的向上调整算法
    void FilterUp(int start);
public:
    MinHeap();
    MinHeap(int capacity);
    MinHeap(vector<T> data);
    ~MinHeap();

    //返回data在vector中的索引
    int GetIndex(T data);
    //删除最小堆中的data
    bool Remove(T data);
    //将data插入到最小堆中
    void Insert(T data);
    //打印
    void Print();
};

template <typename T>
MinHeap<T>::MinHeap(vector<T> data)
{
    for (auto val : data)
    {
        Insert(val);
    }
}


template <typename T>
MinHeap<T>::MinHeap(int capacity)
{
    m_array.reserve(capacity);
    m_capacity = capacity;
}

template <typename T>
MinHeap<T>::MinHeap()
{
    m_array.reserve(100);
}


template <typename T>
MinHeap<T>::~MinHeap()
{
    m_size = 0;
    m_array.clear();
}

//得到data的索引，-1表示未找到
template <typename T>
int MinHeap<T>::GetIndex(T data)
{
    for (int i = 0; i < m_size; ++i)
    {
        if (m_array[i] == data)
            return i;
    }
    return -1;
}


/*
* 最小堆的向下调整算法
*
* 数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。
*
* start -- 被下调节点的起始位置(一般为0，表示从第1个开始)
* end   -- 截至范围(一般为数组中最后一个元素的索引)
*/
template <typename T>
void MinHeap<T>::FilterDown(int start, int end)
{
    int current = start;//当前结点位置
    int left = 2 * current + 1;//左儿子位置
    T tmp = m_array[current];//当前结点大小

    while (left <= end)
    {
        if (left < end && m_array[left] > m_array[left + 1])
        {
            left++;//左右孩子选较小者
        }
        if (tmp <= m_array[left])
            break;//调整结束
        else
        {
            m_array[current] = m_array[left];
            current = left;
            left = 2 * left + 1;
        }
    }
    m_array[current] = tmp;
}

//删除最小堆中的data
template <typename T>
bool MinHeap<T>::Remove(T data)
{
    int index;
    if (m_size == 0)
        return false;
    index = GetIndex(data);
    if (index == -1)
        return false;
    m_array[index] = m_array[--m_size];
    m_array.erase(m_array.end() - 1);
    FilterDown(index, m_size - 1);
    return true;
}

//向上调整
template <typename T>
void MinHeap<T>::FilterUp(int start)
{
    int current = start;
    int p = (current - 1) / 2;//父结点位置
    T tmp = m_array[current];
    while (current > 0)
    {
        if (m_array[p] <= tmp)
            break;
        else
        {
            m_array[current] = m_array[p];
            current = p;
            p = (p - 1) / 2;
        }
    }
    m_array[current] = tmp;
}


template <typename T>
void MinHeap<T>::Insert(T data)
{
    m_array.push_back(data);
    m_size++;
    FilterUp(m_size - 1);
}


template <typename T>
void MinHeap<T>::Print()
{
    for (auto val : m_array)
    {
        cout << val << " ";
    }
}

 

测试：

#include "BinaryHeap.h"

int main()
{
    int tmp;
    vector<int> vec{ 80, 40, 30, 60, 90, 70, 10, 50, 20 };
    MinHeap<int> heap(vec);
    cout << "最小堆为：";
    heap.Print();
    cout << "\n请输入要添加的元素";
    cin >> tmp;
    heap.Insert(tmp);
    cout << "添加之后最小堆为：";
    heap.Print();
    cout << "\n请输入要删除的元素：";
    cin >> tmp;
    heap.Remove(tmp);
    cout << "删除之后最小堆为：";
    heap.Print();

}