Leftist Heaps

Leftist Trees

• Definition -- a binary tree in which at each vertex, V, the path length from V's

right child to the nearest non-full vertex is not larger than that from the V's left
child to the nearest non-full node.
 
• Non-full node -- a node with less than 2 children

 
• Resulting Property -- At every vertex, the shortest path to a non-full node is along

the right-most path.
 
• Theorem -- In a  leftist tree with N vertices, the number of vertices, R, on the right

most path to a non-full vertex

                    R < = |_ lg (N + 1) _|
 

Leftist Heaps

• Defintion -- a leftist tree in which the values in the verticies satisfy "heap order"

(the tree is partially ordered)
 
 
• Who Cares??? -- Leftist heaps are useful and efficient when it is necessary to merge heaps

 

 

• Melding (Merging Leftist Heaps) -- pseudo-code


    Meld (H1, H2)
    {
        if (rootValue ( H1 )  >  rootValue ( H2 )
        or (root  ( H1 ) is NULL
            swap ( H1, H2 )

        if ( root ( H1 ) is not NULL )
        {
               right ( H1 ) = Meld ( right ( H1), H2 )
            if ( leftLength ( H1 ) < rightLength ( H1 )
                swap ( left ( H1 ), right ( H1 ) )
        {

        return H1
    }
 
 

• Performance of Meld??

 

 

• Operations

 
• findMin ( ) -- returns the root

 
• insert (Object x)

    make x into a 1-vertex LH
    Meld ( *this, x )
 
• deleteMin ( )

    Meld ( LeftSubtree, RightSubtree )
 
• construct LH from N object

    naive approach
        make N 1-vertex LHs
        for each element, Meld it with the growing heap

   clever approach --- use a queue and build heap "pair-wise"
    {
        make N 1-vertex LHs

       Queue    Q;

        for ( i = 1; i <= N; i++ )
            Q.Enqueue ( H_i )

        Heap H = Q.Dequeue ( );

        while ( ! Q.IsEmpty ( ) )
        {
            Q.Enqueue ( Meld (H, Q.Dequeue ( ) );
            H = Q.Dequeue ( );
        }
    }