CS-102 BT_24_3_14 Binary Tree Lectures.pdf

1
Operations on Heaps
• Maintain/Restore the max-heap property
– MAX-HEAPIFY
• Create a max-heap from an unordered array
– BUILD-MAX-HEAP
• Sort an array in place
– HEAPSORT
• Priority queues

2
Maintaining the Heap Property
• Suppose a node is smaller than a child
– Left and Right subtrees of i are max-heaps
• To eliminate the violation:
– Exchange with larger child
– Move down the tree
– Continue until node is not smaller than children

3
Example
MAX-HEAPIFY(A, 2, 10)
A[2] violates the heap property
A[2]  A[4]
A[4] violates the heap property
A[4]  A[9]
Heap property restored

4
Maintaining the Heap Property
• Assumptions:
– Left and Right
subtrees of i
are max-heaps
– A[i] may be
smaller than its
children
Alg: MAX-HEAPIFY(A, i, n)
1. l ← LEFT(i)
2. r ← RIGHT(i)
3. if l ≤ n and A[l] > A[i]
4. then largest ←l
5. else largest ←i
6. if r ≤ n and A[r] > A[largest]
7. then largest ←r
8. if largest  i
9. then exchange A[i] ↔ A[largest]
10. MAX-HEAPIFY(A, largest, n)

Initializing A Max Heap
input array = [-, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
8
4
7
6 7
8 9
3
7
10
1
11
5
2

Start at rightmost array position that has a child.
8
4
7
6 7
8 9
3
7
10
1
11
5
2
Index is n/2.

Move to next lower array position.
8
4
7
6 7
8 9
3
7
10
1
5
11
2

8
4
7
6 7
8 9
3
7
10
1
5
11
2

8
9
7
6 7
8 4
3
7
10
1
5
11
2

8
9
7
6 3
8 4
7
7
10
1
5
11
2

8
9
7
6 3
8 4
7
7
10
1
5
11
Find a home for 2.

8
9
7
6 3
8 4
7
7
5
1
11
Find a home for 2.
10

8
9
7
6 3
8 4
7
7
2
1
11
Done, move to next lower array position.
10
5

8
9
7
6 3
8 4
7
7
2
1
11
10
5
Find home for 1.

11
8
9
7
6 3
8 4
7
7
2
10
5
Find home for 1.

8
9
7
6 3
8 4
7
7
2
11
10
5
Find home for 1.

8
9
7
6 3
8 4
7
7
2
11
10
5
Done.
1

Time Complexity
8
7
6 3
4
7
7
10
11
5
2
9
8
1
Height of heap = h.
Number of subtrees with root at level j is <= 2 j-1.
Time for each subtree is O(h-j+1).

Complexity
Time for level j subtrees is <= 2j-1(h-j+1) = t(j).
Total time is t(1) + t(2) + … + t(h-1) = O(n).

23
Example: A 4 1 3 2 16 9 10 14 8 7
Heap Sort

CS-102 BT_24_3_14 Binary Tree Lectures.pdf

26
Alg: HEAPSORT(A)
1. BUILD-MAX-HEAP(A)
2. for i ← length[A] downto 2
3. do exchange A[1] ↔ A[i]
4. MAX-HEAPIFY(A, 1, i - 1)
Running time: O(nlgn) --- Can be
shown to be Θ(nlgn)
O(n)
O(lgn)
n-1 times

27
The ADT Priority Queue
• A priority queue is an ADT in which items are
ordered by a priority value. The item with the
highest priority is always the next to be removed
from the queue. (Highest Priority In, First Out:
HPIFO) or (Best In, First Out: BIFO)
• Supported operations include:
– Create an empty priority queue
– Destroy a priority queue
– Determine whether a priority queue is empty
– Insert a new item into a priority queue
– Retrieve, and then delete from the priority queue the item
with the highest priority value
• We shall implement a priority queue using a heap.

Priority Queue using Max Heap
30 12 18 8 14 41 3 39

Priority Queue using Min Heap
30 12 18 8 14 41 3 39

32
Summary
• We can perform the following operations on
heaps:
– MAX-HEAPIFY O(lgn)
– BUILD-MAX-HEAP O(n)
– HEAP-SORT O(nlgn)
– MAX-HEAP-INSERT O(lgn)
– HEAP-EXTRACT-MAX O(lgn)
– HEAP-INCREASE-KEY O(lgn)
– HEAP-MAXIMUM O(1)
Average
O(lgn)

Leftist Trees
Linked binary tree.
Can do everything a heap can do and in the
same asymptotic complexity.
Can meld two leftist tree priority queues in
O(log n) time.

Extended Binary Trees
Start with any binary tree and add an
external node wherever there is an
empty subtree.
Result is an extended binary tree.

An Extended Binary Tree
number of external nodes is n+1

The Function s()
For any node x in an extended binary tree,
let s(x) be the length of a shortest path
from x to an external node in the subtree
rooted at x.

s() Values Example
0 0 0 0
0 0
0 0
0
0
1 1 1
2 1 1
2 1
2

Properties of s()
If x is an external node, then s(x) = 0.
Otherwise,
s(x) = min {s(leftChild(x)),
s(rightChild(x))} + 1

Height Biased Leftist Trees
A binary tree is a (height biased) leftist tree
iff for every internal node x,
s(leftChild(x)) >= s(rightChild(x))

A Leftist Tree
0 0 0 0
0 0
0 0
0
0
1 1 1
2 1 1
2 1
2

Leftist Trees--Property 1
In a leftist tree, the rightmost path is a
shortest root to external node path and
the length of this path is s(root).

A Leftist Tree
0 0 0 0
0 0
0 0
0
0
1 1 1
2 1 1
2 1
2
Length of rightmost path is 2.

Leftist Trees—Property 2
The number of internal nodes is at least
2s(root) - 1
Because levels 1 through s(root) have no
external nodes.
So, s(root) <= log(n+1)

A Leftist Tree
0 0 0 0
0 0
0 0
0
0
1 1 1
2 1 1
2 1
2
Levels 1 and 2 have no external nodes.

Leftist Trees—Property 3
Length of rightmost path is O(log n), where
n is the number of nodes in a leftist tree.
Follows from Properties 1 and 2.

Leftist Trees As Priority Queues
Min leftist tree … leftist tree that is a min tree.
Used as a min priority queue.
Max leftist tree … leftist tree that is a max tree.
Used as a max priority queue.

A Min Leftist Tree
8 6 9
6 8 5
4 3
2

Some Min Leftist Tree Operations
put()
remove()
meld()
initialize()
put() and remove() use meld().

51
Weight-Biased Leftist Tree
(WBLT)
• Let the weight, w(x), of node x to be the number of internal
nodes in the subtree with root x
• If x is an external node, w(x) = 0
• If x is an internal node, its weight is one more than the sum
of the weights of its children
• A binary tree is a weight-biased leftist tree (WBLT) iff at
every internal node, the w value of the left child is greater
than or equal to the w value of the right child

52
Extended Binary Tree
Figure 12.6 s and w values

When drawing two max HBLTs that are to be
melded, we will always draw the one with larger
root value on the left.
Ties are broken arbitrarily. Because of this
convention, the root of the left HBLT always
becomes the root of the final HBLT.
Also, we will shade the nodes of the HBLT on the
right.

54
Melding max HBLTs
Figure 12.7 Melding (combining) max HBLTs

To create a max HBLT
• 7, 1, 9, 11 and 2

Initializing in O(n) Time
• create n single node max (min) leftist trees
and place them in a FIFO queue
• repeatedly remove two max (min) leftist
trees from the FIFO queue, meld them, and
put the resulting max (min) leftist tree into
the FIFO queue
• the process terminates when only 1 max
(min) leftist tree remains in the FIFO queue
• analysis is the same as for heap initialization

Complexity
• Insertion - O(log n)
• Deletion - O(log n)
• Find max – O(1)
• Melding - O(log n)
• Initialization - O(n)

CS-102 BT_24_3_14 Binary Tree Lectures.pdf

Recommended

More Related Content

Similar to CS-102 BT_24_3_14 Binary Tree Lectures.pdf (20)

More from ssuser034ce1 (20)

Recently uploaded (20)

CS-102 BT_24_3_14 Binary Tree Lectures.pdf