1. Chapter 9 Priority Queues, Heaps, and Graphs

2. 2 Goals Describe a priority queue at the logical level and implement a priority queue as a list Describe the shape and order property of a heap and implement a heap in a nonlinked tree representation in an array Implement a priority queue as a heap Compare the implementations of a priority queue using a heap, a linked list, and a binary search tree

3. 3 Goals Define the following terms related to graphs: Directed graphComplete graph Undirected graphWeighted graph VertexAdjacency matrix EdgeAdjacency list Path Implement a graph using an adjacency matrix to represent the edges

4. 4 Goals Explain the difference between a depth-first and a breadth-first search and implement these searching strategies using stacks and queues for auxiliary storage Implement a shortest-path operation, using a priority queue to access the edge with the minimum weight Describe a set at the logical level and implement a set both explicitly and implicitly

5. 5 Priority Queue An ADT in which only the item with the highest priority can be accessed

6. 6 Priority Queue Items on a priority queue are made up of pairs Can you think of how a priority queue might be implemented as An unsorted list? An array-based sorted list? A linked sorted list? A binary search tree?

7. 7 Heaps Heap A complete binary tree, each of whose elements contains a value that is greater than or equal to the value of each of its children Remember? Complete tree

8. 8 Heaps Heap with letters 'A'.. 'J'

9. 9 Heaps Another heap with letters 'A'.. 'J'

10. 10 Heaps C A T treePtr 50 20 18 30 10 Are these heaps? treePtr

11. 11 Heaps 70 60 40 30 12 810 treePtr Is this a heap?

12. 12 Heaps 70 60 40 30 12 8 treePtr Can we use this fact to implement an efficient PQ? Where is the largest element?

13. 13 Heaps We have immediate access to highest priority item BUT if we remove it, the structure isn't a heap Can we "fix" the problem efficiently?

14. 14 Heaps Shape property is restored. Can order property be restored?

15. 15 Heaps How?

16. 16 Heaps

17. 17 Heaps template struct HeapType { void reheapDown(int root, int bottom); … ItemType* elements; // Dynamic array int numElements; }

18. 18 Heaps 70 0 60 1 40 3 30 4 12 2 8 5 root Number nodes left to right by level

19. 19 Heaps 70 0 60 1 40 3 30 4 12 2 8 5 tree [ 0 ] [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] 70 60 12 40 30 8 elements Use number as index

20. 20 Heaps ReapDown(heap, root, bottom) if heap.elements[root] is not a leaf Set maxChild to index of child with larger value if heap.elements[root] < heap.elements[maxChild] Swap(heap.elements[root], heap.elements[maxChild]) ReheapDown(heap, maxChild, bottom) What variables do we need? Where are a node's children?

21. 21 Heaps // IMPLEMENTATION OF RECURSIVE HEAP MEMBER FUNCTIONS void HeapType ::ReheapDown(int root, int bottom) // Pre: ItemType overloads the relational operators // root is the index of the node that may violate the // heap order property // Post: Heap order property is restored between root and // bottom { int maxChild ; int rightChild ; int leftChild ; leftChild = root * 2 + 1 ; rightChild = root * 2 + 2 ;

22. 22 Heaps if (leftChild <= bottom)// ReheapDown continued { if (leftChild == bottom) maxChild = leftChld; else { if (elements[leftChild] <= elements[rightChild]) maxChild = rightChild; else maxChild = leftChild; } if (elements[root] < elements[maxChild]) { Swap(elements[root], elements[maxChild]); ReheapDown(maxChild, bottom); }

23. 23 Heaps What other operations might our HeapType need?

24. 24 Heaps Add K: Where must the new node be put? Now what?

25. 25 Heaps

26. 26 void HeapType::ReheapUp(int root, int bottom) // Pre: ItemType overloads the relational operators // bottom is the index of the node that may violate // the heap order property. The order property is // satisfied from root to next-to-last node. // Post:Heap order property is restored between root and // bottom { int parent; if (bottom > root) { parent = ( bottom - 1 ) / 2; if (elements[parent] < elements[bottom]) { Swap(elements[parent], elements[bottom]); ReheapUp(root, parent); }

27. 27 Heaps How can heaps be used to implement Priority Queues?

28. 28 Priority Queues class FullPQ(){}; class EmptyPQ(){}; template class PQType { public: PQType(int); ~PQType(); void MakeEmpty(); bool IsEmpty() const; bool IsFull() const; void Enqueue(ItemType newItem); void Dequeue(ItemType& item); private: int length; HeapType items; int maxItems; };

29. 29 Priority Queues template PQType ::PQType(int max) { maxItems = max; items.elements = new ItemType[max]; length = 0; } template void PQType ::MakeEmpty() { length = 0; } template PQType ::~PQType() { delete [] items.elements; }

30. 30 Priority Queues Dequeue Set item to root element from queue Move last leaf element into root position Decrement length items.ReheapDown(0, length-1) Enqueue Increment length Put newItem in next available position items.ReheapUp(0, length-1)

31. 31 Priority Queues template void PQType ::Dequeue(ItemType& item) { if (length == 0) throw EmptyPQ(); else { item = items.elements[0]; items.elements[0] = items.elements[length-1]; length--; items.ReheapDown(0, length-1); }

32. 32 Priority Queues template void PQType ::Enqueue(ItemType newItem) { if (length == maxItems) throw FullPQ(); else { length++; items.elements[length-1] = newItem; items.ReheapUp(0, length-1); }

33. 33 Comparison of Priority Queue Implementations EnqueueDequeue HeapO(log 2 N) Linked ListO(N) Binary Search Tree BalancedO(log 2 N) SkewedO(N)

34. 34 Graphs Graph A data structure that consists of a set of models and a set of edges that relate the nodes to each other Vertex A node in a graph Edge (arc) A pair of vertices representing a connection between two nodes in a graph Undirected graph A graph in which the edges have no direction Directed graph (digraph) A graph in which each edge is directed from one vertex to another (or the same) vertex

35. 35 Graphs Formally a graph G is defined as follows G = (V,E) where V(G) is a finite, nonempty set of vertices E(G) is a set of edges (written as pairs of vertices)

36. 36 Graphs Vertex Edge or arc Undirected Graphs have no arrows on the edges

37. 37 Graphs Directed edge

38. 38 Graphs What other structure is this ?

39. 39 Graphs Adjacent vertices Two vertices in a graph that are connected by an edge Path A sequence of vertices that connects two nodes in a graph Complete graph A graph in which every vertex is directly connected to every other vertex Weighted graph A graph in which each edge carries a value

40. 40 Graphs How many edges in a directed graph with N vertices? How many edges in an undirected graph with N vertices?

41. 41 Graphs Weight

42. 42 Graph Algorithms Depth-first search algorithm Visit all the nodes in a branch to its deepest point before moving up Breadth-first search algorithm Visit all the nodes on one level before going to the next level Single-source shortest-path algorithm An algorithm that displays the shortest path from a designated starting node to every other node in the graph

43. 43 Graphs Operations: The usual suspects IsFull IsEmpty Initialize Insert requires two operations Add vertex Add Edge Others? Let's see.

44. 44 Graphs DepthFirstSearch Set found to false stack.Push(startVertex) do stack.Pop(vertex) if vertex = endVertex Write final vertex Set found to true else Write this vertex Push all adjacent vertices onto stack while !stack.IsEmpty() AND !found if (!found) Write "Path does not exist"

45. 45 Graphs Try depth first search from Austin

46. 46 Graphs Do you see a problem? Do you have a solution?

47. 47 Graphs We need to "mark" a vertex as visited ClearMarks MarkVertex(VertexType, vertex) Boolean IsMarked(VertexType, vertex)

48. 48 Graphs BreadthFirstSearch Set found to false queue.Enqueue(startVertex) do queue.Dequeue(vertex) if vertex = endVertex Write final vertex Set found to true else if (vertex is not marked) Mark vertex Write vertex Get a queue of outgoing vertices from vertex while (vertexQ is not empty) vertexQ.Dequeue(Item) if (item is not marked) queue.Enqueue(item) while queue IsEmpty() AND !found if (!found) Write "Path does not exist"

49. 49 Graphs Try depth breadth search from Austin

50. 50 Graphs DFS uses a stack; BFS uses a queue

51. 51 Graphs BFS result

52. 52 Graphs What other operation does the Graph ADT need?

53. 53 Array-Based Implementation Adjacency Matrix For a graph with N nodes, an N by N table that shows the existence (and weights) of all edges in the graph Mapping Array An array that maps vertex names into array indexes Marking Associate a Boolean variable with each vertex: true if visited, false if not yet visited

54. 54 Adjacency Matrix for Flight Connections Where could marking variable be kept?

55. 55 Linked Implementation Adjacency List A linked list that identifies all the vertices to which a particular vertex is connected; each vertex has its own adjacency list

56. 56 Adjacency List Representation of Graphs Where could a marking variable go ?

57. 57 Sets Set An unordered collection of distinct values (items or components), chosen from the possible values of a single data type, called the component or base type Base type The type of the items in the set Cardinality The number of items in a set Subset A set contained within another set

58. 58 Sets Universal set A set that contains all the values of the base type Empty set A set with no members Set union A set made up of all the items in either sets Set intersection A set made up of all the items in both sets Set difference A set made up of all the items in the first set that are not in the second set

59. 59 Sets Given SetA = {X, Y, Z, A, B} SetB = {A, C, W, Z} What is SetA union SetB? What is SetA intersection SetB? What is SetA - SetB (difference)? Give a subset of SetA Give a proper subset of SetB

60. 60 Sets Beware –At the Logical Level sets can not contain duplicates –Inserting a duplicate item into a set does not change the set – Sets are not ordered This does not mean that we cannot implement a set using an ordered structure with duplicates

61. 61 Sets Explicit implementation Each item in the base type has a representation in each instance of a set; the representation is either true (item is in the set) or false (item is not in the set) Bit Vector An array of Boolean flags, with each item in the base type mapped to a specific flag (index) Algorithms use Boolean operations To what is space for each set instance proportional?

62. 62 Sets If sets A and B are represented as bit vectors, what Boolean operation would implement set union? Set intersection? Set difference?

63. 63 Sets Implicit implementation (List) The items in an instance of a set are on a list that represents the set; those items that are not on the list are not in the set Algorithms use ADT List operations To what is space for each set instance proportional?

64. 64 Sets If sets A and B are represented as lists, what list operations would implement set union? Set intersection? Set difference? Which list implementation would be more efficient?