1 heaps a heap is a binary tree. a heap is best implemented in sequential representation (using an...

1

Heaps

• A heap is a binary tree.• A heap is best implemented in sequential

representation (using an array).• Two important uses of heaps are:

– (i) efficient implementation of priority queues– (ii) sorting -- Heapsort.

2

A Heap

10

2030

40 50 25 55

52 42

Any node’s key value isless than its children’s.

3

Sequential Representation of Trees

• There are three methods of representing a binary tree using array representation.1. Using index values to represent edges:

class Node {Data elt;int left;int right;

} Node;Node[] BinaryTree[TreeSize];

4

Method 1: Example

A

D

B C

E

G

I

Index Element Left Right

1 A 2 3

2 B 4 6

3 C 0 0

4 D 0 0

5 I 0 0

6 E 7 0

7 G 5 0

5

Method 2

2. Store the nodes in one of the natural traversals:

class Node {

StdElementelt;boolean left;boolean right;

};Node[] BinaryTree[TreeSize];

6

Method 2: Example

A

D

B C

E

G

I

Index Element Left Right

1 A T T

2 B T T

3 D F F

4 E T F

5 G T F

6 I F F

7 C F F

Elements stored in Pre-Order traversal

7

Method 3

3. Store the nodes in fixed positions: (i) root goes into first index, (ii) in general left child of tree[i] is stored in tree[2i] and right child in tree[2i+1].

8

Method 3: Example

A

D

B C

E

G

A B C D E - - - - G -

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

9

Heaps

• Heaps are represented sequentially using the third method.

• Heap is a complete binary tree: shortest-path length tree with nodes on the lowest level in their leftmost positions.

• Complete Binary Tree: let h be the height of the heap– for i = 0, … , h - 1, there are 2i nodes of depth i

– at depth h - 1, the internal nodes are to the left of the external

nodes

Heaps (Cont.)

• Max-Heap has max element as root. Min-Heap has min element as root.

• The elements in a heap satisfy heap conditions: for Min-Heap: key[parent] < key[left-child] or key[right-child].

• The last node of a heap is the rightmost node of maximum depth

10

2

65

79 last node

11

Heap: An example

10

2030

40 50 25 55

52 42

[1] 10 10 10

[2] 20 30 40

[3] 25 20 20

[4] 30 40 50

[5] 40 50 42

[6] 42 25 30

[7] 50 55 25

[8] 52 52 52

[9] 55 42 55

For the heap shown

All the three arrangementssatisfy min heap conditions

12

Constructing Heaps

• There are two methods of constructing heaps: – Using SiftDown operation.– Using SiftUp operation.

• SiftDown operation inserts a new element into the Heap from the top.

• SiftUp operation inserts a new element into the Heap from the bottom.

13

ADT Heap

Elements: The elements are called HeapElements.public class HeapElement<T> { T data; Priority p;

public HeapElement(T e, Priority pty) { data = e; p = pty;

Other methods in Java code }

Structure: The elements of the heap satisfy the heap conditions.

Domain: Bounded. Type name: Heap.

14

ADT Heap

Operations:

1. Method SiftUp (int n)

requires: Elements H[1],H[2],…,H[n-1] satisfy heap conditions.

results: Elements H[1],H[2],…,H[n] satisfy heap conditions.

2. Method SiftDown (int m,n)

requires: Elements H[m+1],H[m+2],…,H[n] satisfy the heap conditions.

results: Elements H[m],H[m+1],…,H[n] satisfy the heap conditions.

3. Method Heap (int n) // Constructor

results: Elements H[1],H[2],….H[n] satisfy the heap conditions.

Heaps 15

Insertion into a Heap

• Method insertItem of the priority queue ADT corresponds to the insertion of a key k to the heap

• The insertion algorithm consists of three steps– Find the insertion node z

(the new last node)– Store k at z– Restore the heap-order

property (discussed next)

2

65

79

insertion node

2

65

79 1

z

z

© 2010 Goodrich, Tamassia

Heaps 16

Upheap• After the insertion of a new key k, the heap-order property may be

violated• Algorithm upheap restores the heap-order property by swapping k along

an upward path from the insertion node• Upheap terminates when the key k reaches the root or a node whose

parent has a key smaller than or equal to k • Since a heap has height O(log n), upheap runs in O(log n) time

2

15

79 6z

1

25

79 6z


Heaps 17

Removal from a Heap (§ 7.3.3)• Method removeMin of the

priority queue ADT corresponds to the removal of the root key from the heap

• The removal algorithm consists of three steps– Replace the root key with

the key of the last node w– Remove w – Restore the heap-order

property (discussed next)

2

65

79

last node

w

7

65

9

w

new last node


Heaps 18

Downheap• After replacing the root key with the key k of the last node, the heap-

order property may be violated• Algorithm downheap restores the heap-order property by swapping key

k along a downward path from the root• Upheap terminates when key k reaches a leaf or a node whose children

have keys greater than or equal to k • Since a heap has height O(log n), downheap runs in O(log n) time

7

65

9

w

5

67

9

w


Heaps 19

Updating the Last Node• The insertion node can be found by traversing a path of O(log n) nodes

– Go up until a left child or the root is reached– If a left child is reached, go to the right child– Go down left until a leaf is reached

• Similar algorithm for updating the last node after a removal


Heaps 20

Heap-Sort• Consider a priority queue

with n items implemented by means of a heap– the space used is O(n)– methods insert and

removeMin take O(log n) time

– methods size, isEmpty, and min take time O(1) time

• Using a heap-based priority queue, we can sort a sequence of n elements in O(n log n) time

• The resulting algorithm is called heap-sort

• Heap-sort is much faster than quadratic sorting algorithms, such as insertion-sort and selection-sort


Heaps 21

Vector-based Heap Implementation• We can represent a heap with n keys

by means of a vector of length n + 1• For the node at rank i

– the left child is at rank 2i– the right child is at rank 2i + 1

• Links between nodes are not explicitly stored

• The cell of at rank 0 is not used• Operation insert corresponds to

inserting at rank n + 1• Operation removeMin corresponds to

removing at rank n• Yields in-place heap-sort

2

65

79

2 5 6 9 7

1 2 3 4 50


Heaps 22

• We can construct a heap storing n given keys in using a bottom-up construction with log n phases

• In phase i, pairs of heaps with 2i -1 keys are merged into heaps with 2i+1-1 keys

Bottom-up Heap Construction

2i -1 2i -1

2i+1-1


Heaps 23

Example

1516 124 76 2023

25

1516

5

124

11

76

27

2023


Heaps 24

Example (contd.)

25

1516

5

124

11

96

27

2023

15

2516

4

125

6

911

23

2027


Heaps 25

Example (contd.)

7

15

2516

4

125

8

6

911

23

2027

4

15

2516

5

127

6

8

911

23

2027


Heaps 26

Example (end)

4

15

2516

5

127

10

6

8

911

23

2027

5

15

2516

7

1210

4

6

8

911

23

2027


Heaps 27

Merging Two Heaps• We are given two two

heaps and a key k• We create a new heap

with the root node storing k and with the two heaps as subtrees

• We perform downheap to restore the heap-order property

7

3

58

2

64

3

58

2

64

2

3

58

4

67


28

HeapSort

• Heap can be used for sorting. Two step process:– Step 1: the data is put in a heap.– Step 2: the data are extracted from the heap in

sorted order.

• HeapSort based on the idea that heap always has the smallest or largest element at the root.

Heaps 29

Heaps and Priority Queues• We can use a heap to implement a priority queue• We store a (key, element) item at each internal node• We keep track of the position of the last node

(2, Sue)

(6, Mark)

(5, Pat)

(9, Jeff)

(7, Anna)


30

ADT Heap: Implementation

//This method extracts elements in sorted order from the heap. Heap size becomes 0.

public void HeapSort(){ while (size>1){ swap(heap, 1, size); size--; SiftDown(1); }//Display the sorted elements. for(int i = 1; i<=maxsize; i++)

{ System.out.println(heap[i].get_priority().get_value());

} }

31

Priority Queue as Heap

Representation as a Heappublic class HeapPQ<T> { Heap<T> pq; /** Creates a new instance of HeapPQ */ public HeapPQ() { pq = new Heap(10); }

32


public void enqueue(T e, Priority pty){ HeapElement<T> x = new HeapElement<T>

(e, pty); pq.SiftUp(x);}

33


public T serve(Priority pty){ T e; Priority p; e = pq.heap[1].get_data(); p = pq.heap[1].get_priority(); pty.set_value(p.get_value()); pq.heap[1] = pq.heap[pq.size]; pq.size--; pq.SiftDown(1); return(e); }

34


public int length(){ return pq.size; } public boolean full(){ return false; }

1 heaps a heap is a binary tree. a heap is best implemented in sequential representation (using an...

Documents