左式堆的實現與詳解

定義：左式堆（Leftist Heaps)又稱作最左堆、左傾堆，是計算機語言中較為常用的一個數據結構。左式堆作為堆的一種，保留了堆的一些屬性。第1，左式堆仍然以二叉樹的形式構建；第2，左式堆的任意結點的值比其子樹任意結點值均小（最小堆的特性）。但和一般的二叉堆不同，左式堆不再是一棵完全二叉樹（Complete tree)，而且是一棵極不平衡的樹。

性質：

零路徑長：從X到一個不具有兩個兒子的結點的最短路徑的長。

1. 任一結點的零路徑長比他的諸兒子結點的零路徑長的最小值多1

2. 父節點屬性值小於子節點屬性值；

3. 堆中的任何節點，其左兒子的零路徑長>=右兒子的零路徑長的二叉樹。

操作：

左式堆的操作都是基於合並，而合並僅對右路做合並，而右路結點的數量為總數量的對數關系，所以左式堆的三個操作（合並，刪除，插入）所花的時間為O(logN).

左式堆的合並操作基於遞歸完成，算法如下：

1.如果有一棵樹是空樹，則返回另一棵樹；否則遞歸地合並根結點較小的堆的右子樹和根結點較大的堆。

2.使形成的新堆作為較小堆的右子樹。

3.如果違反了左式堆的特性，交換兩個子樹的位置。

4.更新Npl。

 刪除最小值/最大值：

刪除操作的做法相當的簡單，刪除左式堆的根節點，合並左右子樹即可。

插入：將需要插入的節點當做一棵左式堆樹，進行合並即可。

 

下面給出左式堆的c++類模板實現

#include <iostream>
using namespace std;

template <typename Comparable>
class LeftistHeap
{
public:
    LeftistHeap() :root(NULL){}
    LeftistHeap(const LeftistHeap &rhs)
    {
        *this = rhs;
    }
    ~LeftistHeap()
    { 
        MakeEmpty(); 
    }

    bool IsEmpty() const;
    const Comparable &FindMin() const;

    void Insert(const Comparable &x);
    void DeleteMin();
    void DeleteMin(Comparable &minItem);
    void MakeEmpty();
    void Merge(LeftistHeap &rhs);

    const LeftistHeap &operator=(const LeftistHeap &rhs);

private:
    struct LeftistNode
    {
        Comparable element;
        LeftistNode *left;
        LeftistNode *right;
        int npl;

        LeftistNode(const Comparable &theElement, LeftistNode *lt = NULL, LeftistNode *rt = NULL, int np = 0) :
            element(theElement), left(lt), right(rt), npl(np){}
    };
    LeftistNode *root;

    LeftistNode *Merge(LeftistNode *h1, LeftistNode *h2);
    LeftistNode *Merge1(LeftistNode *h1, LeftistNode *h2);

    void SwapChildren(LeftistNode *t);
    void ReclaimMemory(LeftistNode *t);
    LeftistNode *Clone(LeftistNode *t) const
    {
        if (t == NULL)
            return NULL;
        else
            return new LeftistNode(t->element, clone(t->left), clone(t->right));
    }

};



template <typename Comparable>
bool LeftistHeap<Comparable>::IsEmpty() const
{
    return root == NULL;
}

template <typename Comparable>
void LeftistHeap<Comparable>::Insert(const Comparable &x)
{
    root = Merge(new LeftistNode(x), root);
}

template <typename Comparable>
void LeftistHeap<Comparable>::Merge(LeftistHeap &rhs)
{
    if (this == &rhs)//避免和自己合並
        return;
    root = Merge(root, rhs.root);
    rhs.root = NULL;
}

template <typename Comparable>
void LeftistHeap<Comparable>::SwapChildren(LeftistNode *t)
{
    LeftistNode *tmp = t->left;
    t->left = t->right;
    t->right = tmp;
}

template <typename Comparable>
typename LeftistHeap<Comparable>::LeftistNode *LeftistHeap<Comparable>::Merge1(LeftistNode *h1, LeftistNode *h2)
{
    if (h1->left == NULL)
        h1->left = h2;
    else
    {
        h1->right = Merge(h1->right, h2);
        if (h1->left->npl < h1->right->npl)
            SwapChildren(h1);
        h1->npl = h1->right->npl + 1;
    }
    return h1;
}

template <typename Comparable>
typename LeftistHeap<Comparable>::LeftistNode *LeftistHeap<Comparable>::Merge(LeftistNode *h1, LeftistNode *h2)
{
    if (h1 == NULL)
        return h2;
    if (h2 == NULL)
        return h1;
    if (h1->element < h2->element)
        return Merge1(h1, h2);
    else
        return Merge1(h2, h1);
}





template <typename Comparable>
void LeftistHeap<Comparable>::DeleteMin()
{
    if (IsEmpty())
        return;
    LeftistNode *oldRoot = root;
    root = Merge(root->left, root->right);
    delete oldRoot;
}


template <typename Comparable>
void LeftistHeap<Comparable>::DeleteMin(Comparable &minItem)
{
    minItem = FindMin();
    DeleteMin();
}

template <typename Comparable>
const Comparable & LeftistHeap<Comparable>::FindMin() const
{
    if (!IsEmpty())
        return root->element;
}


template <typename Comparable>
void LeftistHeap<Comparable>::ReclaimMemory(LeftistNode *t)
{
    if (t != NULL)
    {
        ReclaimMemory(t->left);
        ReclaimMemory(t->right);
        delete t;
    }
}


template <typename Comparable>
void LeftistHeap<Comparable>::MakeEmpty()
{
    ReclaimMemory(root);
    root = NULL;
}

 

#include "LeftistHeap.h"


int main()
{
    LeftistHeap<int> leftistHeap1, leftistHeap2;
    int m, n, num;
    cin >> m;
    for (int i = 0; i < m; ++i)
    {
        cin >> num;
        leftistHeap1.Insert(num);
    }

    cin >> n;
    for (int i = 0; i < n; ++i)
    {
        cin >> num;
        leftistHeap2.Insert(num);
    }

    leftistHeap1.Merge(leftistHeap2);
    cout << "min num is " << leftistHeap1.FindMin() << endl;
    if (leftistHeap1.IsEmpty())
    {
        cout << "leftistHeap1 is Empty!" << endl;
    }
    else
    {
        cout << "leftistHeap1 is not empty!" << endl;
    }

    int t;
    while (leftistHeap1.IsEmpty() == false)
    {
            leftistHeap1.DeleteMin(t);
            cout << t << " ";
    }
        cout << endl;
    if (leftistHeap1.IsEmpty())
    {
            cout << "leftistHeap1 is empty!" << endl;
    }
    else
    {
            cout << "leftistHeap1 is not empty!" << endl;
    }

}