Priority Queues. 04/10/03 Lecture 22 1

Transcription

1 Priority Queues It is a variant of queues Each item has an associated priority value. When inserting an item in the queue, the priority value is also provided for it. The data structure provides a method to delete the item with the highest priority. 04/10/03 Lecture 22 1

2 package weiss.nonstandard; Priority Queues // PriorityQueue interface // // ******************PUBLIC OPERATIONS********************* // Position insert( x ) --> Insert x // Comparable deletemin( )--> Return and remove smallest item // Comparable findmin( ) --> Return smallest item // boolean isempty( ) --> Return true if empty; else false // void makeempty( ) --> Remove all items // int size( ) --> Return size // void decreasekey( p, v)--> Decrease value in p to v // ******************ERRORS******************************** // Throws UnderflowException for findmin and deletemin when empty 04/10/03 Lecture 22 2

3 Applications of Priority Queues Implementing job queues in computer systems, or queues in an emergency room in a hospital. Implementing Dijkstra s shortest path algorithm 04/10/03 Lecture 22 3

4 Binary Search Trees // BinarySearchTree class // // **************PUBLIC OPERATIONS***************** // void insert( x ) --> Insert x O(h) // void remove( x ) --> Remove x O(h) // void removemin( ) --> Remove minimum item O(h) // Comparable find( x ) --> Return item that matches x O(h) // Comparable findmin( ) --> Return smallest item O(h) // Comparable findmax( ) --> Return largest item O(h) // boolean isempty( ) --> Return true if empty; else false // void makeempty( ) --> Remove all items The height of the tree =? O(log n) on the average, and O(n) on the worst case. 04/10/03 Lecture 22 4

5 Balanced Binary Search Trees There can be many binary search trees for the same data. Not all of them have the same characteristics. Some are better than the others. Worst case height of the binary search tree is O(log n) More work when you insert or delete, because you try to fix any imbalances in the tree caused by the change. No change when you search, because the tree is still a binary search tree. 04/10/03 Lecture 22 5

6 Figure (a) The balanced tree has a depth of log N; (b) the unbalanced tree has a depth of N 1. 04/10/03 Lecture 22 6

7 Figure Binary search trees that can result from inserting a permutation 1, 2, and 3; the balanced tree shown in part (c) is twice as likely to result as any of the others. 04/10/03 Lecture 22 7

8 Figure Minimum tree of height H 04/10/03 Lecture 22 8

9 Figure Single rotation to fix case 1 04/10/03 Lecture 22 9

10 Figure Single rotation fixes an AVL tree after insertion of 1. 04/10/03 Lecture 22 10

11 Applications of Balanced BSTs Anywhere where you want to store a dynamic set of items. Static means that the items in the set are fixed at the start and do not change. To implement static sets, a sorted array would do well. Dynamic means that the items in the set are changing (inserts and deletes). Balanced BSTs guarantee the worst-case performance of the data structure. 04/10/03 Lecture 22 11

12 Disjoint Set Union-Find Data Structure Maintains disjoint sets. Main operations: Union: unions two given sets Find: finds set containing given item 04/10/03 Lecture 22 12

13 Disjoint Set Union-Find Data Structure public class DisjointSets { public DisjointSets( int numelements ) public void union( int root1, int root2 ) public int find( int x ) private int [ ] s; } 04/10/03 Lecture 22 13

14 Figure A forest and its eight elements, initially in different sets 04/10/03 Lecture 22 14

15 Figure The forest after the union of trees with roots 4 and 5 04/10/03 Lecture 22 15

16 Figure The forest after the union of trees with roots 6 and 7 04/10/03 Lecture 22 16

17 Figure The forest after the union of trees with roots 4 and 6 04/10/03 Lecture 22 17

18 Figure The forest formed by union-by-size, with the sizes encoded as negative numbers 04/10/03 Lecture 22 18

19 Applications: Disjoint Set Union- Find Data Structure Minimum Spanning Tree problem 04/10/03 Lecture 22 19

20 Figure 24.6 (a) A graph G and (b) its minimum spanning tree 04/10/03 Lecture 22 20

21 Figure 24.7 (A) Kruskal s algorithm after each edge has been considered. The stages proceed left-to-right, top-to-bottom, as numbered. (continued) 04/10/03 Lecture 22 21

22 Figure 24.7 (B) Kruskal s algorithm after each edge has been considered. The stages proceed left-to-right, top-to-bottom, as numbered. 04/10/03 Lecture 22 22

23 Figure 24.1 A 50 x 88 maze 04/10/03 Lecture 22 23

24 Figure 24.2 Initial state: All walls are up, and all cells are in their own sets. 04/10/03 Lecture 22 24

25 Figure 24.3 At some point in the algorithm, several walls have been knocked down and sets have been merged. At this point, if we randomly select the wall between 8 and 13, this wall is not knocked down because 8 and 13 are already connected. 04/10/03 Lecture 22 25

26 Figure 24.4 We randomly select the wall between squares 18 and 13 in Figure 24.3; this wall has been knocked down because 18 and 13 were not already connected, and their sets have been merged. 04/10/03 Lecture 22 26

27 Figure 24.5 Eventually, 24 walls have been knocked down, and all the elements are in the same set. 04/10/03 Lecture 22 27