二叉堆的實現

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

二叉堆有兩種：最大堆和最小堆。

最大堆：父結點的鍵值總是大於或等於任何一個子結點的鍵值；

最小堆：父結點的鍵值總是小於或等於任何一個子節點的鍵值。

二叉堆一般都通過"數組"來實現。數組實現的二叉堆，父節點和子節點的位置存在一定的關系。我們將"二叉堆的第一個元素"放在數組索引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();

}