Data Structures (Weiss) Chapter 6: Leftist Heap

Definition of null path length, npl(X), of any node X to be the length of the shortest path from X to a node without two children. Thus, the npl of a node with zero or one child is 0, while npl(NULL)=-1.

The leftist heap is that for every node X in the heap, the null path length of the left child is at least as large as that of the right child. The key of parent is always no more than the key of its children. The leftist heap is very unbalanced. 

//

//  main.cpp

//  Data Structure TRY1

//

//  Created by zr9558 on 6/7/13.

//  Copyright (c) 2013 zr9558. All rights reserved.

//

// Data Structure C++, Weiss, P.229 Section 6.6 Leftist Heaps

#include<iostream>

using namespace std;

template<typename Comparable>

class LeftistHeap

{

public:

    LeftistHeap() {root=NULL;}

    LeftistHeap(constLeftistHeap &rhs)

    {

       root=NULL;

       operator=(rhs);

    }

    ~LeftistHeap()

    {

       makeEmpty();

    }

    

   bool isEmpty()const

    {

       returnroot==NULL;

    }

    

   const Comparable &findMin()const

    {

       returnroot->element;

    }

    

   void insert(const Comparable &x) ;

   void deleteMin();

   void deleteMin( Comparable & minItem);

   void makeEmpty();

   void merge(LeftistHeap &rhs);

    

    constLeftistHeap &operator =(constLeftistHeap &rhs)

    {

       if(this != &rhs)

        {

           makeEmpty();

           root=clone(rhs.root);

        }

       return *this;

    }

    

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)

    {

       if( h1==NULL)return h2;

       if( h2==NULL)return h1;

       if( h1->element<h2->element)returnmerge1(h1,h2);

       elsereturnmerge1(h2,h1);

    }

    

    LeftistNode *merge1(LeftistNode *h1,LeftistNode *h2)

    {

       if( h1->left==NULL)//Single Node

            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 *temp=t->left;

        t->left=t->right;

        t->right=temp;

        

        

    }

    

   void reclaimMemory(LeftistNode *t);

    

    LeftistNode *clone(LeftistNode *t)const

    {

       if( t==NULL)returnNULL;

        

       returnnew LeftistNode(t->element,clone(t->left),clone(t->right),t->npl);

    }

    

};

template<typename Comparable>

void LeftistHeap<Comparable>::insert(const Comparable &x)

{

   root = merge(newLeftistNode(x),root);

}

template<typename Comparable>

void LeftistHeap<Comparable>::deleteMin()

{

   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>

void LeftistHeap<Comparable>::merge(LeftistHeap &rhs)

{

   if(this==&rhs)return;

    

   root=merge(root,rhs.root);

    rhs.root=NULL;

}

template<typename Comparable>

void LeftistHeap<Comparable>::makeEmpty()

{

   while( !isEmpty())

        deleteMin();

}

int main()

{

    LeftistHeap<int> H;

    

   for(int i=4; i<20; ++i)

        H.insert(i%11);

    

    LeftistHeap<int> H1;

    H1=H;

    

   while( !H.isEmpty())

    {

       cout<<H.findMin()<<" ";

        H.deleteMin();

    }

    cout<<endl;

    

   while( !H1.isEmpty())

    {

       cout<<H1.findMin()<<" ";

        H1.deleteMin();

    }

    cout<<endl;

    

    return 0;

}