Using a Heap to Implement a Priority Queue

Size: px

Start display at page:

Download "Using a Heap to Implement a Priority Queue"

Veronica Sharp
6 years ago
Views:

1 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 226] Using a Heap to Implement a Priority Queue To implement the priority queue operation insert(x): 1. Make a new node in the tree in the next available location, marching across from left to right. 2. Put x in the new node. 3. Bubble x up the tree until finding a correct place: if xéparent s key, then swap keys and continue. Time: Oèlog nè To implement the priority queue operation remove(): Tricky part is how to remove the root without messing up the tree structure. 1. Swap the key in the root with the key (call it y) in the rightmost node on the bottom level. 2. Remove the rightmost node on the bottom level. 3. Bubble down the new root s key y until finding a correct place: if y é at least one child s key, then swap y with smallest child s key and continue. Time: Oèlog nè.

2 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 227] Using a Heap to Implement a PQ (cont d) 3 insert(2) remove PQ operation sorted array unsorted array heap or linked list or linked list insert Oènè Oè1è Oèlog nè remove (min) Oè1è Oènè Oèlog nè No longer have the severe tradeoffs of the array and linked list representations of priority queue. By keeping the keys semi-sorted instead of fully sorted, we can decrease the tradeoff between the costs of insert and remove.

3 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 228] Heap Sort Recall the sorting algorithm that used a priority queue: 1. insert the elements to be sorted, one by one, into a priority queue. 2. remove the elements, one by one, from the priority queue; they will come out in sorted order. If the priority queue is implemented with a heap, the running time is Oèn log nè. This is much better than Oèn 2 è. This algorithm is called heap sort.

4 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 229] Linked Structure Implementation of Heap To implement a heap with a linked structure, each node of the tree will be represented with an object containing æ key (data) æ pointer to parent node æ pointer to left child æ pointer to right child To find the next available location for insert, or the rightmost node on the bottom level for remove, in constant time, keep all nodes on the same level in a linked list. Thus each node will also have æ pointer to left neighbor on same level æ pointer to right neighbor on same level Then keep a single pointer for the whole heap that points to the rightmost node on the bottom level.

5 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 230] Array Implementation of Heap Fortunately, there s a nifty way to implement a heap using an array, based on an interesting observation: If you number the nodes in a leftmost binary tree, starting at the root and going across levels and down levels, you see a pattern: æ Node number i has left child 2 æ i. æ Node number i has right child 2 æ i +1. æif 2 æ ién, then i has no left child. æ If 2 æ i +1én, then i has no right child. æ Therefore, node number i is a leaf if 2 æ ién. æthe parent of node i is bi=2c, as long as ié1. ænext available location for insert is index n +1. ærightmost node on the bottom level is index n.

6 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 231] Array Implementation of Heap (cont d) Representation consists of æ array A[1..max] (ignore location 0) æ integer n, which is initially 0, holding number of elements in heap To implement insert(x) (ignoring overflow): n := n+1 // make a new leaf node A[n] := x // new node s key is initially x cur := n // start bubbling x up parent := cur/2 while (parent!= 0) && A[parent] > A[cur] do // current node is not the root and its key // has not found final resting place swap A[cur] and A[parent] cur := parent // move up a level in the tree parent := cur/2 endwhile

7 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 232] Array Implementation of Heap (cont d) To implement remove (ignoring underflow): minkey := A[1] // smallest key, to be returned A[1] := A[n] // replace root s key with key in // rightmost leaf on bottom level n := n-1 // delete rightmost leaf on bottom level cur := 1 // start bubbling down key in root Lchild := 2*cur Rchild := 2*cur + 1 while (Lchild <= n) && (A[minChild()] < A[cur]) do // current node is not a leaf and its key has // not found final resting place swap A[cur] and A[minChild()] cur := minchild() // move down a level in the tree Lchild := 2*cur Rchild := 2*cur + 1 endwhile return minkey minchild(): // returns index of child w/ smaller key min := Lchild if (Rchild <= n) && (A[Rchild] < A[Lchild]) then // node has a right child and it is smaller min := RChild endif return min

8 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 233] Binary Tree Traversals Now consider any kind of binary tree with data in the nodes, not just leftmost binary trees. In many applications, we need to traverse a tree: visit each node exactly once. When the node is visited, some computation can take place, such as printing the key. There are three popular kinds of traversals, differing in the order in which each node is visited in relation to the order in which its left and right subtrees are visited: æ inorder traversal: visit the node IN between visiting the left subtree and visiting the right subtree æ preorder traversal: visit the node BEFORE visiting either subtree æ postorder traversal: visit the node AFTER visiting both its subtrees In all cases, it is assumed that the left subtree is visited before the right subtree.

9 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 234] Binary Tree Traversals (cont d) preorder(x): if x is not empty then visit x preorder(leftchild(x)) preorder(rightchild(x)) inorder(x): if x is not empty then inorder(leftchild(x)) visit x inorder(rightchild(x)) postorder(x): if x is not empty then postorder(leftchild(x)) postorder(rightchild(x)) visit x a b c d f g æ preorder: a b d e c f g h i æ inorder: d e b a f c h g i æ postorder: e d b f h i g c e h i

10 CPSC 211 Data Structures & Implementations (c) Texas A&M University [ 235] Binary Tree Traversals (cont d) These traversals are particularly interesting when the binary tree is a parse tree for an arithmetic expression: æ Postorder traversal results in the postfix representation of the expression. æ Preorder gives prefix representation. æ Does inorder give infix? No, because there are no parentheses to indicate precedence. * æ preorder: * æ inorder: * æ postorder: * 2-1

Section 5.5. Left subtree The left subtree of a vertex V on a binary tree is the graph formed by the left child L of V, the descendents

Section 5.5. Left subtree The left subtree of a vertex V on a binary tree is the graph formed by the left child L of V, the descendents Section 5.5 Binary Tree A binary tree is a rooted tree in which each vertex has at most two children and each child is designated as being a left child or a right child. Thus, in a binary tree, each vertex