左式堆 - 码农教程

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

性质：

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

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

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

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

 1 template <typename Comparable>
 2 class LeftistHeap
 3 {
 4 public:
 5     LeftistHeap();
 6     LeftistHeap(const LeftistHeap & rhs);
 7     ~LeftistHeap();
 8 
 9     bool isEmpty() const;
10     const Comparable & findMin() const;
11 
12     void insert(const Comparable & x);
13     void deleteMin();
14     void deleteMin(Comparable & minItem);
15     void makeEmpty();
16     void merge(LeftistHeap & rhs);
17 
18     const LeftistHeap & operator=(const LeftistHeap & rhs);
19 
20 private:
21     struct LeftistNode
22     {
23         Comparable element;
24         LeftistNode *left;
25         LeftistNode *right;
26         int npl;
27 
28         LeftistNode(const Comparable & theElement,LeftistNode *lt = NULL,LeftistNode *rt = NULL,int np=0)
29             :element(theElement),left(lt),right(rt),npl(np)
30         {
31         }
32     };
33     LeftistNode *root;
34     LeftistNode * merge(LeftistHeap *h1,LeftistHeap *h2);
35     LeftistNode * merge1(LeftistHeap *h1,LeftistHeap *h2);
36 
37     void swapChildren(LeftistHeap *t);
38     void reclaimMemory(LeftistHeap *t);
39     LeftistNode * clone(LeftistHeap *t) const;
40 }

合并左式堆的驱动实例：

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);
}

合并左式堆的实例：

 1 LeftistNode * mergel(LeftistNode *h1,LeftistNode *h2)
 2 {
 3     if(h1->left == NULL)
 4         h1->left = h2;
 5     else
 6     {
 7         h1->right = merge(h1->right,h2);
 8         if(h1->left->npl < h1->right->npl)
 9             swapChildren(h1);
10         h1->npl = h1->right->npl + 1;
11     }
12     return h1;
13 }

左式堆的插入操作：

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

左式堆的deleteMin操作：

 1  void deleteMin()
 2  {
 3      if(isEmpty())
 4          throw UnderflowException();
 5      LeftistNode * oldRoot = root;
 6      root = merge(root->left,root->right);
 7      delete oldRoot;
 8  }
 9  void deleteMin(Comparable & minItem)
10  {
11     minItem = findMin();
12     deleteMin();
13  }

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

  1 #ifndef LeftistHeap_h__
  2 #define LeftistHeap_h__
  3 #define    NULL    0
  4 // ******************公共操作*********************
  5 // void insert( x )       --> 插入x
  6 // deleteMin( minItem )   --> 删除最小元素
  7 // Comparable findMin( )  --> 返回最小元素
  8 // bool isEmpty( )        --> 为空返回true，否则返回false
  9 // void makeEmpty( )      --> 清空
 10 // void merge( rhs )      --> 合并rhs到本堆中
 11 // ******************说明********************************
 12 //    代码根据数据结构与算法分析中的代码编写
 13 template <typename Comparable>
 14 class LeftistHeap
 15 {
 16 public:
 17     LeftistHeap():root(NULL)
 18     {}
 19     LeftistHeap(const LeftistHeap &rhs)
 20     {
 21         *this = rhs;
 22     }
 23     ~LeftistHeap()
 24     {
 25         makeEmtpy();
 26     }
 27     //插入x元素
 28     void insert(const Comparable &x)
 29     {
 30         root = merge(new LeftistNode(x), root);
 31     };
 32     //为空返回true，否则返回false
 33     bool isEmpty() const
 34     {
 35         return root == NULL;
 36     }
 37     //找到最小元素并返回其值
 38     const Comparable& findMin() const
 39     {
 40         if(!isEmpty())
 41             return root->element;
 42     }
 43     //删除最小元素
 44     void deleteMin()
 45     {
 46         if(isEmpty())
 47             return;
 48         LeftistNode* oldroot = root;
 49         root = merge(root->left, root->right);
 50         delete oldroot;
 51     }
 52     //删除最小元素，并将其值赋予minItem
 53     void deleteMin(Comparable &minItem)
 54     {
 55         minItem = findMin();
 56         deleteMin();
 57     }
 58     //清空
 59     void makeEmtpy()
 60     {
 61         reclaimMemory(root);
 62         root = NULL;
 63     }
 64     //将另一个堆合并到本堆中
 65     void merge(LeftistHeap &rhs)
 66     {
 67         if(this == &rhs)
 68             return;
 69         root = merge(root, rhs.root);
 70         rhs.root = NULL;
 71     }
 72     const LeftistHeap& operator=(const LeftistHeap &rhs)
 73     {
 74         if(this != &rhs)
 75         {
 76             makeEmtpy();
 77             root = clone(rhs.root);
 78         }
 79         return *this;
 80     }
 81 private:
 82     struct LeftistNode
 83     {
 84         Comparable    element;
 85         LeftistNode    *left;
 86         LeftistNode    *right;
 87         int            npl;
 88         LeftistNode(const Comparable &e, LeftistNode *l = NULL,
 89             LeftistNode *r = NULL, int n = 0)
 90             :element(e), left(l), right(r), npl(n)
 91         {}
 92     };
 93     LeftistNode *root;
 94     //处理非一般情况，并递归调用merge1
 95     LeftistNode* merge(LeftistNode *h1, LeftistNode *h2)
 96     {
 97         if(h1 == NULL)
 98             return h2;
 99         if(h2 == NULL)
100             return h1;
101         if(h1->element < h2->element)
102             merge1(h1, h2);
103         else
104             merge1(h2, h1);
105     }
106     //合并两个节点
107     //h1是具有最小元素的根节点
108     LeftistNode* merge1(LeftistNode *h1, LeftistNode *h2)
109     {
110         if(h1->left == NULL)
111             h1->left = h2;
112         else
113         {
114             h1->right = merge(h1->right, h2);
115             if(h1->left->npl < h1->right->npl)
116                 swapChildren(h1);
117             h1->npl = h1->right->npl + 1;
118         }
119         return h1;
120     }
121     void swapChildren(LeftistNode *t)
122     {
123         LeftistNode *tmp = t->left;
124         t->left = t->right;
125         t->right = tmp;
126     }
127     void reclaimMemory(LeftistNode *t)
128     {
129         if(t != NULL)
130         {
131             reclaimMemory(t->left);
132             reclaimMemory(t->right);
133             delete t;
134         }
135     }
136     LeftistNode *clone(LeftistNode *t) const
137     {
138         if(t == NULL)
139             return NULL;
140         else
141             return new LeftistNode(t->element, clone(t->left), clone(t->right));
142     }
143 };
144 #endif // LeftistHeap_h__

 1 #include "LeftistHeap.h"
 2 #include <cstdlib>
 3 #include <ctime>
 4 #include <iostream>
 5 using namespace std;
 6 int main()
 7 {
 8     LeftistHeap<int> leftistHeapA, leftistHeapB, leftistHeapC;
 9     srand((unsigned)time(0));  
10     for(int i=0; i< 1000; i++)  
11     {  
12         int t = rand();   
13         leftistHeapA.insert(t);
14     }
15     for(int i=0; i< 1000; i++)  
16     {  
17         int t = rand();   
18         leftistHeapB.insert(t);
19     }
20     leftistHeapA.merge(leftistHeapB);
21     leftistHeapA.merge(leftistHeapC);
22     int t;
23     while(leftistHeapA.isEmpty() == false)
24     {
25         leftistHeapA.deleteMin(t);
26         cout<<t<<" ";
27     }
28     cout<<endl;
29     getchar();
30     return 0;
31 }