左式堆的实现与详解

定义：左式堆（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;
    }

}