左式堆

零路径长：从X到一个不具有两个儿子的结点的最短路径的长。

性质：

任一结点的零路径长比他的诸儿子结点的零路径长的最小值多1

父节点属性值小于子节点属性值；

堆中的任何节点，其左儿子的零路径长>=右儿子的零路径长；的二叉树。

下面是左式堆的类型声明：

template <typename Comparable>
class LeftistHeap
{
public:
    LeftistHeap();
    LeftistHeap(const LeftistHeap & rhs);
    ~LeftistHeap();

    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(LeftistHeap *h1,LeftistHeap *h2);
    LeftistNode * merge1(LeftistHeap *h1,LeftistHeap *h2);

    void swapChildren(LeftistHeap *t);
    void reclaimMemory(LeftistHeap *t);
    LeftistNode * clone(LeftistHeap *t) const;
}

合并左式堆的驱动实例：

void merge(LeftistHeap & rhs)
{
    if(this == &rhs)
        return;
    root = merge(root,rhs.root );
    rhs.root = NULL;
}
LeftistNode * merge(LeftistNode * h1,LeftistNode *h2)
{
    if(h1 == NULL)
        return h2;
    if(h2 == NULL)
        return h1;
    if(h1->element < h2->element)
        return mergel(h1,h2);
    else
        return mergel(h2,h1);
}

合并左式堆的实例：

LeftistNode * mergel(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;
}

左式堆的插入操作：

void insert(const Comparable & x)
{
    root = merge(new LeftListNode(x),root);
}

左式堆的deleteMin操作：

 void deleteMin()
 {
     if(isEmpty())
         throw UnderflowException();
     LeftistNode * oldRoot = root;
     root = merge(root->left,root->right);
     delete oldRoot;
 }
 void deleteMin(Comparable & minItem)
 {
    minItem = findMin();
    deleteMin();
 }

下面是左式堆的应用实例：

#ifndef LeftistHeap_h__
#define LeftistHeap_h__
#define    NULL    0
// ******************公共操作*********************
// void insert( x )       --> 插入x
// deleteMin( minItem )   --> 删除最小元素
// Comparable findMin( )  --> 返回最小元素
// bool isEmpty( )        --> 为空返回true，否则返回false
// void makeEmpty( )      --> 清空
// void merge( rhs )      --> 合并rhs到本堆中
// ******************说明********************************
//    代码根据数据结构与算法分析中的代码编写
template <typename Comparable>
class LeftistHeap
{
public:
    LeftistHeap():root(NULL)
    {}
    LeftistHeap(const LeftistHeap &rhs)
    {
        *this = rhs;
    }
    ~LeftistHeap()
    {
        makeEmtpy();
    }
    //插入x元素
    void insert(const Comparable &x)
    {
        root = merge(new LeftistNode(x), root);
    };
    //为空返回true，否则返回false
    bool isEmpty() const
    {
        return root == NULL;
    }
    //找到最小元素并返回其值
    const Comparable& findMin() const
    {
        if(!isEmpty())
            return root->element;
    }
    //删除最小元素
    void deleteMin()
    {
        if(isEmpty())
            return;
        LeftistNode* oldroot = root;
        root = merge(root->left, root->right);
        delete oldroot;
    }
    //删除最小元素，并将其值赋予minItem
    void deleteMin(Comparable &minItem)
    {
        minItem = findMin();
        deleteMin();
    }
    //清空
    void makeEmtpy()
    {
        reclaimMemory(root);
        root = NULL;
    }
    //将另一个堆合并到本堆中
    void merge(LeftistHeap &rhs)
    {
        if(this == &rhs)
            return;
        root = merge(root, rhs.root);
        rhs.root = NULL;
    }
    const LeftistHeap& operator=(const LeftistHeap &rhs)
    {
        if(this != &rhs)
        {
            makeEmtpy();
            root = clone(rhs.root);
        }
        return *this;
    }
private:
    struct LeftistNode
    {
        Comparable    element;
        LeftistNode    *left;
        LeftistNode    *right;
        int            npl;
        LeftistNode(const Comparable &e, LeftistNode *l = NULL,
            LeftistNode *r = NULL, int n = 0)
            :element(e), left(l), right(r), npl(n)
        {}
    };
    LeftistNode *root;
    //处理非一般情况，并递归调用merge1
    LeftistNode* merge(LeftistNode *h1, LeftistNode *h2)
    {
        if(h1 == NULL)
            return h2;
        if(h2 == NULL)
            return h1;
        if(h1->element < h2->element)
            merge1(h1, h2);
        else
            merge1(h2, h1);
    }
    //合并两个节点
    //h1是具有最小元素的根节点
    LeftistNode* 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;
    }
    void swapChildren(LeftistNode *t)
    {
        LeftistNode *tmp = t->left;
        t->left = t->right;
        t->right = tmp;
    }
    void reclaimMemory(LeftistNode *t)
    {
        if(t != NULL)
        {
            reclaimMemory(t->left);
            reclaimMemory(t->right);
            delete t;
        }
    }
    LeftistNode *clone(LeftistNode *t) const
    {
        if(t == NULL)
            return NULL;
        else
            return new LeftistNode(t->element, clone(t->left), clone(t->right));
    }
};
#endif // LeftistHeap_h__

#include "LeftistHeap.h"
#include <cstdlib>
#include <ctime>
#include <iostream>
using namespace std;
int main()
{
    LeftistHeap<int> leftistHeapA, leftistHeapB, leftistHeapC;
    srand((unsigned)time(0));  
    for(int i=0; i< 1000; i++)  
    {  
        int t = rand();   
        leftistHeapA.insert(t);
    }
    for(int i=0; i< 1000; i++)  
    {  
        int t = rand();   
        leftistHeapB.insert(t);
    }
    leftistHeapA.merge(leftistHeapB);
    leftistHeapA.merge(leftistHeapC);
    int t;
    while(leftistHeapA.isEmpty() == false)
    {
        leftistHeapA.deleteMin(t);
        cout<<t<<" ";
    }
    cout<<endl;
    getchar();
    return 0;
}