Graph Searching
(JAVA)
Hira Awais
Lecturer (DCS)
DDSA (FOC)
Slide courtesy: Dr. Zahid Halim
Graph Searching
Given: a graph G = (V, E), directed or undirected
Goal: methodically explore every vertex and every edge
Ultimately: build a tree on the graph
Pick a vertex as the root
Choose certain edges to produce a tree
Breadth-First Search
Given a G=(V,E) and distinguished source vertex s, BFS systematically
explores the edges of G to “discover” every vertex reachable from s.
Creates a BFS tree rooted at s that contains all such vertices.
Expands the frontier between discovered and undiscovered vertices
uniformly across the breadth of the frontier.
The algorithm discovers all vertices at distance k from s before discovering
any vertices at distance k+1
Breadth-First Search
will associate vertex “colors” to guide the algorithm
White vertices have not been discovered
▪ All vertices start out white
Grey vertices are discovered but not fully explored
▪ They may be adjacent to white vertices and represent the frontier between the discovered and the
undiscovered.
Black vertices are discovered and fully explored
▪ They are adjacent only to black and gray vertices
Explore vertices by scanning adjacency list of grey vertices
Breadth-First Search – Pseudo Code
1. BFS(G, s) {
2. initialize vertices;
3. Q = {s}; // Q is a queue initialize to s
4. while (Q not empty) {
5. u = Dequeue(Q);
6. for each v u->adj {
7. if (v->color == WHITE){
8. v->color = GREY;
9. v->d = u->d + 1;
10. v->p = u;
11. Enqueue(Q, v);
12. }
13. }
14. u->color = BLACK;
15. }
16. }
Breadth-First Search - Example
r s t u
v w x y
Breadth-First Search: Example
r s t u
0
v w x y
Q: s
Breadth-First Search: Example
r s t u
1 0
1
v w x y
Q: w r
Breadth-First Search: Example
r s t u
1 0 2
1 2
v w x y
Q: r t x
Breadth-First Search: Example
r s t u
1 0 2
2 1 2
v w x y
Q: t x v
Breadth-First Search: Example
r s t u
1 0 2 3
2 1 2
v w x y
Q: x v u
Breadth-First Search: Example
r s t u
1 0 2 3
2 1 2 3
v w x y
Q: v u y
Breadth-First Search: Example
r s t u
1 0 2 3
2 1 2 3
v w x y
Q: u y
Breadth-First Search: Example
r s t u
1 0 2 3
2 1 2 3
v w x y
Q: y
Breadth-First Search: Example
r s t u
1 0 2 3
2 1 2 3
v w x y
Q: Ø
Breadth-First Search: Properties
BFS calculates the shortest-path distance to the source node
Shortest-path distance (s,v) = minimum number of edges from s to
v, or if v not reachable from s
BFS builds breadth-first tree, in which paths to root represent
shortest paths in G
Thus can use BFS to calculate shortest path from one vertex to
another in O(V+E) time
Applications of BFS
Web Crawlers
Search engines or web crawlers can easily build multiple levels of indexes by
employing BFS. BFS implementation starts from the source, which is the web
page, and then it visits all the links from that source.
P2P Networks
BFS can be implemented to locate all the nearest or neighboring node in a P2P
network. This will find the required data faster.
Un-weighted graph
BFS can easily create the shortest path and minimum spanning tree to visit all
the vertices of the graph in the shortest possible time with high accuracy.
Depth First Search
Depth-first search: Strategy Go as deep as can visiting un-visited
nodes
Choose any un-visited vertex when you have a choice
When stuck at a dead-end, backtrack as little as possible back up
to where you could go to another unvisited vertex
Then continue to go on from that point
Eventually you’ll return to where you started
DFS Algorithm
DFS(G)
for each vertex u V[G]{
color[u]=white
parent[u]=NULL
}
time=0
for each vertex u V[G]{
if color[u]=white then
DFS-VISIT(u)
}
DFS-VISIT(u)
color[u]=GRAY
time=time+1
d[u]=time
for each vertex v adj[u] {
if color[v]=white Then
parent[v]=u
DFS-VISIT(v)
}
color[u]=black
f[u]=time=time+1
DFS [Easy One]
1. Initialize all nodes to the ready state (STATUS=1)
2. PUSH starting node A on stack and change its status to waiting(STATUS=2)
3. Repeat 4-5 until stack is empty
4. POP N. Process it and change its status to processed(STATUS=3)
5. PUSH on stack all the neighbors of N that are still in ready state and
change their status to waiting
6. Exit
Depth-First Search - Example
Depth-First Search - Example
Depth-First Search - Example
Depth-First Search - Example
Depth-First Search - Example
Depth-First Search - Example
Applications of DFS
Path finding
We can specialize in DFS algorithm to search a path between two
vertices
Detecting a cycle in a graph
A graph has a cycle if we found a back edge during DFS. Therefore, we
should run DFS for the graph and verify for back edges.
Weighted graph
DFS traversal generates the shortest path tree and minimum spanning
tree
BFS VS. DFS
Breadth-First Search Depth-First Search
Find the shortest path to the destination or closet node Finds the longest path or the farthest node to the
to the starting node starting node
Uses queue to keep track of the next location to visit Uses stack to keep track of the next location to visit
Traverses according to tree level Traverses according to tree depth
Implement using FIFO list Implement using LIFO list
Require more memory than DFS Requires less memory than BFS
Algorithm gives shallowest path solution Does not guarantee shallowest path solution
Can never trap in infinite loop Can trap in infinite loop
No need of back tracking Back tracking is needed
Why BFS takes more memory than DFS?
BFS is more memory-intensive than DFS, as it needs to store all
the nodes at each level, while DFS only needs to store the
current path
Difference between BFS & DFS
BFSis more likely to find a solution faster than DFS, if there is
one, as it explores all possible paths at each level while DFS
may get stuck in a dead end or a cycle.
BFS is more predictable than DFS, as it always visits the nodes
in the same order, while DFS may vary depending on the order
of edges.
How to choose between BFS & DFS for a
problem?
Structure and size of the graph
Location & number of the nodes of interest
Type and complexity of the problem
Memory & time constraint
