Height-Biased Leftist Heaps Advanced)

transcript

NUCES-FAST • Advanced Data Structures • Spring 2007

Height-biased Leftist Heaps

Rabea Aden

Friday, 1st May, 2007

For any node X Є Leftist Tree, Rightmost path is the Shortest

Leftist Tree

• Invented by Clark Allan Crane

• A Leftist Tree is a priority queue

• It satisfies the leftist structural property

Null Path Length

• denoted by npl(X)• Length of shortest path from X to an external

npl(NULL) = -1

If X has zero or one child, npl(X) = 0

Otherwise

hild(X))}npl(rightC ild(X)),npl(leftCh { min 1 npl(X)

Null Path Length

if X has zero or one childnpl(X) = 0

else npl(X) = 1 + min{ npl( leftChild(X) ), npl( rightChild(X) ) }

npl(NULL) = -1

-1 -1 -1

NullNullNull

Null Null Null

Structural Property

• Height-biased Leftist Property

• Tree is unbalanced • Biased towards left• Left paths are long, giving the name Leftist Tree• Rightmost path is the shortest

hild(X))npl(rightC ild(X))npl(leftCh HBLT X

Structural Property

Null path lengths: T1 is a Height-biased Leftist Tree, T2 is not

Leftist Heap Property Violatednpl(leftChild) < npl(rightChild)

0 0 0 0

0 0 0 1

Leftist Heap

• A Heap-ordered Leftist Tree

Heap-order Property

• Min Leftist Heap

• Max Leftist Heap

(X))key(Parent key(X) Heap X

If X is root Parent (X) = root

Binary Heap vs. Leftist Heap

Binary Heap Leftist Heap — Perfectly balanced — Very unbalanced

Operations Binary Heap Leftist Heap

BuildHeapFindMinMergeInsertDeleteMin

O(N)O(1)Θ(N)

O(log N)O(log N)

O(N)O(1)

O(log N)O(log N)O(log N)

Binary Heap Leftist Heap — Perfectly balanced — Very unbalanced

Merge is expensive in ordinary Heaps

Operations Binary Heap Leftist Heap

BuildHeapFindMinMergeInsertDeleteMin

O(N)O(1)Θ(N)

O(log N)O(log N)

O(N)O(1)

O(log N)O(log N)O(log N)

Binary Heap vs. Leftist Heap

Theorem

The number of nodes N in a leftist tree

with r nodes on the right path is ≥ 2r -1

Proof is by Induction

This gives

1)(nlogr12N 2r

Structure of a Node

DataLeft

PointerRight

PointerNPL

Apart from data, left and right pointers, each node also contains the null path length

Design

• A Leftist Tree is a priority queue implemented using a variant of the Binary Tree

• A pointer to the root of the leftist tree is also maintained

Extended Binary Tree

Given: A Binary Tree TB

For all empty subtrees є TB

replace each empty subtree with an external node

Binary Tree

Replace each empty subtree with an external node

Internal Node

Extended Binary Tree

Replace each empty subtree with an external nodeThe number outside each node X is the npl(X)

External Node

Since an External Node represents NULLnpl(External Node) = -1

-1 -1 -1 -1

-1 -1 -1

0 -1 0

Internal Node

Operations

• BuildHeap O(N)

• FindMin O(1)

• Merge O(log N)

• Insert O(log N)

• DeleteMin O(log N)

General Idea

• All insertions and merges are performed on the rightmost path containing at most nodes

• This may violate Leftist Heap Property• Leftist Heap Property can be easily restored

1)(nlog2

• O(log N) time

• It is a fundamental operation– Both Insert and DeleteMin are based on Merge– Insert:

• The key to be inserted is a one-node heap• Merge this one-node heap with the given min leftist heap

– DeleteMin• Delete root, left and right child of root are two min leftist heaps• Merge the two min leftist heaps

Merge Algorithm (Recursive)Merge(H1, H2)

If both heaps are Leftist

If one heap is NULL then return the other

If data(H1) > data(H1) then swap H1 and H2

If leftChild(H1) is NULL then leftChild(H1) = H2

Otherwise,

Recursively Merge rightChild(H1) and H2

If Leftist Heap Property is violated i.eIf npl( leftChild(H1) ) < npl( rightChild(H1) ) then swap children of H1

npl(H1) = npl(rightChild(H1)) + 1

Merge H1 & H2

Both H1 and H2 are Min Leftist Heaps

Merge (H1, H2)

Compare root(H1) '2' & root(H2) '3' — H1 has smaller root

Both H1 and H2 are not NULL

Merge H1 & H2

Since, leftChild(H1) ≠ NULL H1 now points to its rightChild

Merge H1 & H2

Merge (H1, H2)

Compare root(H1) '9' & root(H2) '3' — H2 has smaller root swap(H1, H2)

Now, root(H1) = '3' & root(H2) = '9'

Merge H1 & H2

Resizing H1

Merge H1 & H2

Merge (H1, H2)

Merge H1 & H2

Merge (H1, H2)

Now, root(H1) = '9' & root(H2) = '23'

1737941

Merge H1 & H2

Resizing H1

1737941

Merge H1 & H2

1737941

Merge H1 & H2

1737941

Merge (H1, H2)

Now, root(H1) = '23' & root(H2) = '37'

Merge H1 & H2

Since, leftChild(H1) ≠ NULL H1 now points to its rightChild — NULL

1737941

Merge H1 & H2

H1 is NULL

Merge (H1, H2)

Since root(H1) is 'NULL' swap(H1, H2)

Now, root(H1) = '37' & root(H2) = 'NULL'

Merge H1 & H2

H2 is NULL

Adjust Null Path Lengths from the Last Node

on the Rightmost Path to the Root

Merge H1 & H2

Adjust Null Path Lengths from the Last Node

on the Rightmost Pathto the Root

leftChild(H1)→npl ≥ rightChild(H1)→npl — 0 ≥ -1H1→npl = rightChild(H1)→npl + 1 = '0'

npl (NULL) = -1

H1 points to '37'

Leftist Heap Property NOT Violated

Merge H1 & H2

H1 moves up to '23'

leftChild(H1)→npl ≥ rightChild(H1)→npl — 0 ≥ 0H1→npl = rightChild(H1)→npl + 1 = '1'

npl (NULL) = -1

Merge H1 & H2

leftChild(H1)→npl ≥ rightChild(H1)→npl — 0 ≤ 1

H1 moves up to '9'

Leftist Heap Property Violatedswap( leftChild(H1), rightChild(H1) )

Merge H1 & H2

leftChild(H1)→npl ≥ rightChild(H1)→npl — 0 ≤ 1H1→npl = rightChild(H1)→npl + 1 = '1'

H1 moves up to '9'

1*1130

Merge H1 & H2

H1 moves up to '8'

Merge H1 & H2

H1 moves up to '3'130

Merge H1 & H2

0H1 moves up to '2'

Merge H1 & H2

H1 is returned Root pointer now points to H1

Merge Algorithm (Iterative)

Merge(H1, H2)

Pass 1 — Down the HeapSort nodes on rightmost paths of H1 and H2 in ascending order (leftChild of each node remains)A new tree H is created by merging the sorted nodes

Pass 2 — Up the Heap nodes X Є rightmost path of H from leaf to the root

If Leftist Heap Property is violated i.eIf npl( leftChild(X) ) < npl( rightChild(X) ) then swap children of X

npl(X) = npl(rightChild(X) + 1

Time Complexity of Merge

• O(log n)

• As only shortest path is traversed

Insert

• O(log N) time

Insert is based on Merge

Existing min leftist heap — H1 The key to be inserted is a one-node heap — H2 Merge this one-node heap H1 with the given min

leftist heap H2

Insert 3

H1 — existing HeapH2 — one-node heap containing node to be inserted

Both H1 and H2 are Min Leftist Heaps

Insert 3

Merge (H1, H2)

Insert 3

Merge (H1, H2)

Now, root(H1) = '3' & root(H2) = '9'

Both H1 and H2 are not NULL30

Insert 3

Since, leftChild(H1) == NULL leftChild(H1) = H2

Insert 3

H2 is NULLAdjust Null Path Lengths

from the last node on the Rightmost Path

to the Root

Insert 3

npl (NULL) = -1130

Adjust Null Path Lengths from the last node

H1 points to '3'

Insert 3

npl (NULL) = -1130

H1 moves up to '2'

Insert 3

Time Complexity of Insert

• O(log n)

• Create a one-node heap — O(1)• Merge — O(log n)

– As only shortest path is traversed

DeleteMin

• O(log N) time

DeleteMin is based on Merge

Delete root — (minimum value is in root) Left and right children of root are two min

leftist heaps — H1 and H2 respectively Merge the two min leftist heaps H1 and H2

DeleteMin

Delete Minimum Key '2'

DeleteMin

Save old value of rootH1 = root→leftChildH2 = root→rightChild

RootoldRoot

DeleteMin

Merge (H1, H2)

oldRoot

DeleteMin

oldRoot

DeleteMin

oldRoot

Both H1 and H2 are not NULL61

Merge (H1, H2)

Now, root(H1) = '3' & root(H2) = '9'

DeleteMin

oldRoot

DeleteMin

oldRoot

Merge (H1, H2)

Now, root(H1) = '37' & root(H2) = '13'

DeleteMin

oldRoot

Since, leftChild(H1) == NULL leftChild(H1) = H2

DeleteMin

oldRoot

H2 is NULL

DeleteMinoldRoot

npl (NULL) = -1

H1 points to '13'

DeleteMinoldRoot

npl (NULL) = -1

H1 moves up to '9'

DeleteMinoldRoot

H1 moves up to '6'

DeleteMinoldRoot

Delete old value of Root

Time Complexity of DeleteMin

• O(log n)

• Delete root — O(1)• Initialize H1 with left child of root — O(1)• Initialize H2 with right child of root — O(1)• Merge — O(log n)

– As only shortest path is traversed

Brute Force BuildHeap

• O(N logN) time

Based on Insert

Given N elements, create N one-node min leftist heaps and insert them into a Queue, Q

Size of Q, |Q| = N

Root = Remove first min leftist heap from queue

while( |Q| > 0 )Remove one min leftist heaps from queue — HInsert( H )

Build a min leftist heap containing elements7, 9, 37, 41, 2, 6, 13

Create 7 one-node min leftist heaps and insert them in a queue — |Q| = 7

Root = 7 |Q| = 6H = 9 |Q| = 5Insert( H )

Root H

Root = 7 |Q| = 5H = 37 |Q| = 4Insert( H )

Root H

Root = 7 |Q| = 4H = 41 |Q| = 3Insert( H )

Root H

Root = 7 |Q| = 3H = 2 |Q| = 2Insert( H )

Root H

Root = 7 |Q| = 2H = 6 |Q| = 1Insert( H )

Root H

Root = 7 |Q| = 1H = 13 |Q| = 0Insert( H )

Root H

Time Complexity of Brute Force BuildHeap

• O(N log N)

1 insert — O(log N)

N inserts — O(N log N)

Efficient BuildHeap

• O(N) time

Based on Merge

Given N elements, create N one-node min leftist heaps and insert them into a Queue, Q

Size of Q, |Q| = N

while( |Q| > 1 )Remove first two min leftist heaps from queue — H1 and H2Merge H1 and H2 Insert merged min leftist heap into queue

Efficient BuildHeap

Build a min leftist heap containing elements7, 9, 37, 41, 2, 6, 13

Create 7 one-node min leftist heaps and insert them in a queue — |Q| = 7

Efficient BuildHeap

Remove and merge first two min leftist heaps from queue H1 = 7 |Q| = 6H2 = 9 |Q| = 5H1 = Merge(H1, H2)

Insert H1 into queue |Q| = 6

Efficient BuildHeap

Since |Q| > 0Root = 2

Time Complexity of Efficient BuildHeap

Assume min leftist heap contains N = 2k elements

Merge Operations Recursive Calls to Merge

N/2k = 1 k

Time Complexity of Efficient BuildHeap

Total Time for BuildHeap

3nforn3

()3*8N

()2*4N

()1*2N

Height-Biased Leftist Heaps Advanced)

Documents