Queues, Stacks and Heaps

1. Queues, Stacks and Heaps

2. Queue List structure using the FIFO process Nodes are removed form the front and added to the back Front A B C D Back

3. Queue Removing a node (popping) Then adding a node (pushing) Uses include Breadth First Search and other graph-related algorithms Front B C D Back Front B C D A Back

4. Stack List structure using the FILO process Nodes added to and removed from the top Top D C B A Bottom

5. Stack Removing a node Then adding a node popping pushing Top Top C E B C A B A Bottom Bottom

6. Stack Used in Depth First Search and other recursive algorithms

7. Tree Basics A tree is a connected graph with no cycles Nodes can have multiple children and at most one parent Nodes with no children are called leaves Topmost node called the root Root Parent of node 4 2 6 Child of node 8 5 7 3 A leaf

8. Heap A heap is a binary tree - no more than 2 children per parent The binary heap is complete – all levels are full with the possible exception of the last The value of each node is greater than or equal to the values of each of its children

9. Heap Properties of a heap of size n: Height of the heap is trunc(log2n) Root of the heap contains the largest value 10 8 3 1 5 2

10. Heap A heap can be conveniently stored in an array as such: • The root is stored at index 1 • The children of node i are stored at indices 2i and 2i+1 • The parent of node i is stored at index trunc(i/2)

11. Heap A simple heap with array representation 9 8 3 6 5 2 1 4 5 Index 0 1 2 3 4 5 6 7 8 9 Value 0 9 8 3 6 5 2 1 4 5

12. Heap Heap construction: • Read values into array • For each node from the last parent down to the root: If the node value is less than either of the children, switch the node with the greater child Continue until the node value is greater than or equal to both children (automatically true if it is a leaf) • Construction is in O(n)

13. Heap Inserting a value: • Increment the size and add the value as the last node • Sift the node up the heap if it is larger than its parent until its parent is greater than it or it has become the root • Insertion is in O(log2n) 8 8 9 6 5 9 5 8 5 4 9 4 6 4 6

14. Heap Deleting the root (when popping): • Change the value of the root to the value of the last node in the heap and decrement the size of the heap • If the node is less than either child, swap it with the larger child, repeat until it is greater than both children • Deletion is in O(log2n) 9 3 6 6 5 6 5 3 5 2 3 2 2

15. Heap A heap can be used to sort a list of values (heapsort): • Heapify the list of values • Pop the root off and reheap • Repeat until the heap is empty • Deletion of a node is O(log2n) and this is repeated n times, so heapsort is in O(nlog2n) (this is also the worst case) • Heapsort can be done in-place, but it is not a stable sort

16. Priority Queue Priority queues are queues which pop the minimum or maximum value in the queue. As the root of a heap is always the largest or smallest value in the heap, priority queues can use a heap structure. Priority queues have important uses in: • Dijkstra’s Algorithm (shortest path) • Prim’s Algorithm (a faster alternative to Kruskal’s for a minimum spanning tree) • Simply finding the minimum/maximum value of a dynamic list efficiently

17. Problem Examples Shortest path is a fairly common problem, with The Cheese Universe from the first training camp being a straight-forward example. A heap priority queue converts Dijkstra’s to O((E+V)log2n) from O(n2). An example of a minimum spanning tree problem for which Prim’s Algorithm might be used is the Caves of Caerbannog problem from last years SACO.