1. SEARCHING GRAPHS Chapter 16.2

2. INTRO  in our tree discussion, learned three ways of traversing a graph: –Preorder (prefix) –Inorder (infix) –Postorder (postorder)  traversing easy if we begin at root (can get to every other node from there)  in a graph, however, some nodes may not be reachable from a given node, making it impossible to traverse the whole graph  graphs are used to model many real-world systems –ex: towns and connecting railways –some towns may not be reachable on the graph if there is no rail service to that town  two basic search algorithms for graphs: –1) breadth-first –2) depth-first

3. DEPTH-FIRST SEARCH (TREE)  Consider the tree:  Perform depth-first: –Visit each node –Look at its children –Start at 10: Look at 5 Now children of 5: Look at 2 Child of 2: Look at 1 backtrack to 5 Look at 7 Backtrack to 10 –Repeat for right child of 10 –Handle backtracking with a STACK 10 125 271114 1 17

4. DEPTH-FIRST (GRAPH) - same concept as with a tree: - Algorithm: -1) start at a node A -2) go to an adjacent unvisited vertex B: -a) mark it as visited -b) push it onto the stack -3) repeat step 2 until no more adjacent nodes to B remain unvisited -a) pop current node off stack -b) go to next adjacent unvisited vertex, and begin process again -4) if no more unvisited nodes in graph remain, search is done

5. DEPTH-FIRST (GRAPH) - Example: -Start at A: Visit Stack A B AB F ABF C ABFC BACKTRACK ABF H ABFH Backtrack ABF Backtrack AB Backtrack A D AD A BFH C D E GI

6. DEPTH-FIRST (cont.) Example (cont.) VisitStack EADE BacktrackAD GADG IADGI BacktrackADG BacktrackAD BacktrackA Backtrackempty A BFH C D E GI

7. DEPTH-FIRST (cont.) the algorithm can easily be written as a recursive function and by traversing the adjacency matrix/list for the graph from previous example: adjacency list: A-->B-->C-->D-->0 B-->F-->0 C-->B-->0 D-->E-->G-->0 E-->0 F-->C-->H  0 G-->I  0 H-->0 I-->0

8. DEPTH-FIRST (cont.) - Algorithm (adjacency list): start: mark all nodes as unvisited depthfirstsearch(A): for each vertex u in A's list mark it as visited depthfirstsearch(u) once all A's list has been exhausted, move to next UNVISITED vertex: depthfirstsearch(D) repeat until all nodes have been visited

9. DEPTH-FIRST (cont.) - Comments: -Disadv: -is possible that some nodes may still not get visited by depth-search (for example, start at B) -Adv: -good algorithm because it can yield lots of information about the structure of the graph

10. BREADTH-FIRST SEARCH (TREE) - Again consider: - we perform breadth-first by starting at a node, then looking at all children of that node: -Start 10: -Look 5 12 -Look at their children: -Look 2,7,11,14 -And their children: -Look 1, 17 -When no more children, search done -Since we track where we look first, a queue is used 10 125 271114 1 17

11. BREADTH-FIRST (GRAPH) again, similar to that of a tree use a queue to store vertices as they are visited Algorithm Mark all vertices as UNVISITED 1) start at a vertex A 2) visit the next UNVISITED vertex that is adjacent to the current one a) Mark it as VISITED b) Insert it into the queue c) repeat 2 until no more unvisited vertices adjacent to current one 3) Remove next vertex from queue and make it the current vertex 4) Repeat step 2 until no more vertices are unvisited 5) If no unvisited vertices remain (queue is empty) you are done

12. Breath-First (Graph) Again consider: Start at A: Visit Queue A empty B (A->B) B C (A->C) BC D (A->D) BCD no more children of A: remove B CD F CDF no more children of B: remove C DF B already visited, no more children: remove D F A BFH C D E GI

13. BREADTH-FIRST (cont.) - Example (cont.) Visit Queue E FE G FEG remove F EG visit H EGH remove E GH remove G H I HI remove H I remove I queue empty no children of I Queue Empty - Search Done A BFH C D E GI

14. BREADTH-FIRST (discussion) - Implementation: -can easily implement this algorithm with an adjacency list by simply searching the linked list for each node in the list (how would you write it?) - Comments: -again, may be situations where not all vertices are searched, depending on where you start (i.e, starting again at B) -still very good algorithm to use due to its ease of implementation

15. QUESTIONS? MORE GRAPHS P. 735 - 744