# Iterative Depth First Traversal of Graph

Depth First Traversal (or Search) for a graph is similar to Depth First Traversal (DFS) of a tree. The only catch here is, unlike trees, graphs may contain cycles, so a node might be visited twice. To avoid processing a node more than once, use a boolean visited array.

Example:

Input: n = 4, e = 6
0 -> 1, 0 -> 2, 1 -> 2, 2 -> 0, 2 -> 3, 3 -> 3
Output: DFS from vertex 1 : 1 2 0 3
Explanation:
DFS Diagram: Input: n = 4, e = 6
2 -> 0, 0 -> 2, 1 -> 2, 0 -> 1, 3 -> 3, 1 -> 3
Output: DFS from vertex 2 : 2 0 1 3
Explanation:
DFS Diagram: The recursive implementation of DFS is already discussed: previous post.
Solution:

• Approach: Depth-first search is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking. So the basic idea is to start from the root or any arbitrary node and mark the node and move to the adjacent unmarked node and continue this loop until there is no unmarked adjacent node. Then backtrack and check for other unmarked nodes and traverse them. Finally print the nodes in the path.
The only difference between iterative DFS and recursive DFS is that the recursive stack is replaced by a stack of nodes.
• Algorithm:
1. Created a stack of nodes and visited array.
2. Insert the root in the stack.
3. Run a loop till the stack is not empty.
4. Pop the element from the stack and print the element.
5. For every adjacent and unvsisted node of current node, mark the node and insert it in the stack.
• Implementation of Iterative DFS: This is similar to BFS, the only difference is queue is replaced by stack.

## C++

 `// An Iterative C++ program to do DFS traversal from ` `// a given source vertex. DFS(int s) traverses vertices ` `// reachable from s. ` `#include ` `using` `namespace` `std; ` ` `  `// This class represents a directed graph using adjacency ` `// list representation ` `class` `Graph ` `{ ` `    ``int` `V;    ``// No. of vertices ` `    ``list<``int``> *adj;    ``// adjacency lists ` `public``: ` `    ``Graph(``int` `V);  ``// Constructor ` `    ``void` `addEdge(``int` `v, ``int` `w); ``// to add an edge to graph ` `    ``void` `DFS(``int` `s);  ``// prints all vertices in DFS manner ` `    ``// from a given source. ` `}; ` ` `  `Graph::Graph(``int` `V) ` `{ ` `    ``this``->V = V; ` `    ``adj = ``new` `list<``int``>[V]; ` `} ` ` `  `void` `Graph::addEdge(``int` `v, ``int` `w) ` `{ ` `    ``adj[v].push_back(w); ``// Add w to v’s list. ` `} ` ` `  `// prints all not yet visited vertices reachable from s ` `void` `Graph::DFS(``int` `s) ` `{ ` `    ``// Initially mark all verices as not visited ` `    ``vector<``bool``> visited(V, ``false``); ` ` `  `    ``// Create a stack for DFS ` `    ``stack<``int``> stack; ` ` `  `    ``// Push the current source node. ` `    ``stack.push(s); ` ` `  `    ``while` `(!stack.empty()) ` `    ``{ ` `        ``// Pop a vertex from stack and print it ` `        ``s = stack.top(); ` `        ``stack.pop(); ` ` `  `        ``// Stack may contain same vertex twice. So ` `        ``// we need to print the popped item only ` `        ``// if it is not visited. ` `        ``if` `(!visited[s]) ` `        ``{ ` `            ``cout << s << ``" "``; ` `            ``visited[s] = ``true``; ` `        ``} ` ` `  `        ``// Get all adjacent vertices of the popped vertex s ` `        ``// If a adjacent has not been visited, then push it ` `        ``// to the stack. ` `        ``for` `(``auto` `i = adj[s].begin(); i != adj[s].end(); ++i) ` `            ``if` `(!visited[*i]) ` `                ``stack.push(*i); ` `    ``} ` `} ` ` `  `// Driver program to test methods of graph class ` `int` `main() ` `{ ` `    ``Graph g(5); ``// Total 5 vertices in graph ` `    ``g.addEdge(1, 0); ` `    ``g.addEdge(0, 2); ` `    ``g.addEdge(2, 1); ` `    ``g.addEdge(0, 3); ` `    ``g.addEdge(1, 4); ` ` `  `    ``cout << ``"Following is Depth First Traversal\n"``; ` `    ``g.DFS(0); ` ` `  `    ``return` `0; ` `} `

## Java

 `//An Iterative Java program to do DFS traversal from ` `//a given source vertex. DFS(int s) traverses vertices ` `//reachable from s. ` ` `  `import` `java.util.*; ` ` `  `public` `class` `GFG  ` `{ ` `    ``// This class represents a directed graph using adjacency ` `    ``// list representation ` `    ``static` `class` `Graph ` `    ``{ ` `        ``int` `V; ``//Number of Vertices ` `         `  `        ``LinkedList[] adj; ``// adjacency lists ` `         `  `        ``//Constructor ` `        ``Graph(``int` `V) ` `        ``{ ` `            ``this``.V = V; ` `            ``adj = ``new` `LinkedList[V]; ` `             `  `            ``for` `(``int` `i = ``0``; i < adj.length; i++) ` `                ``adj[i] = ``new` `LinkedList(); ` `             `  `        ``} ` `         `  `        ``//To add an edge to graph ` `        ``void` `addEdge(``int` `v, ``int` `w) ` `        ``{ ` `            ``adj[v].add(w); ``// Add w to v’s list. ` `        ``} ` `         `  `        ``// prints all not yet visited vertices reachable from s ` `        ``void` `DFS(``int` `s) ` `        ``{ ` `            ``// Initially mark all vertices as not visited ` `            ``Vector visited = ``new` `Vector(V); ` `            ``for` `(``int` `i = ``0``; i < V; i++) ` `                ``visited.add(``false``); ` `     `  `            ``// Create a stack for DFS ` `            ``Stack stack = ``new` `Stack<>(); ` `             `  `            ``// Push the current source node ` `            ``stack.push(s); ` `             `  `            ``while``(stack.empty() == ``false``) ` `            ``{ ` `                ``// Pop a vertex from stack and print it ` `                ``s = stack.peek(); ` `                ``stack.pop(); ` `                 `  `                ``// Stack may contain same vertex twice. So ` `                ``// we need to print the popped item only ` `                ``// if it is not visited. ` `                ``if``(visited.get(s) == ``false``) ` `                ``{ ` `                    ``System.out.print(s + ``" "``); ` `                    ``visited.set(s, ``true``); ` `                ``} ` `                 `  `                ``// Get all adjacent vertices of the popped vertex s ` `                ``// If a adjacent has not been visited, then push it ` `                ``// to the stack. ` `                ``Iterator itr = adj[s].iterator(); ` `                 `  `                ``while` `(itr.hasNext())  ` `                ``{ ` `                    ``int` `v = itr.next(); ` `                    ``if``(!visited.get(v)) ` `                        ``stack.push(v); ` `                ``} ` `                 `  `            ``} ` `        ``} ` `    ``} ` `     `  `    ``// Driver program to test methods of graph class ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``// Total 5 vertices in graph ` `        ``Graph g = ``new` `Graph(``5``); ` `         `  `        ``g.addEdge(``1``, ``0``); ` `        ``g.addEdge(``0``, ``2``); ` `        ``g.addEdge(``2``, ``1``); ` `        ``g.addEdge(``0``, ``3``); ` `        ``g.addEdge(``1``, ``4``); ` `             `  `        ``System.out.println(``"Following is the Depth First Traversal"``); ` `        ``g.DFS(``0``); ` `    ``} ` `} `

## Python3

 `# An Iterative Python program to do DFS traversal from  ` `# a given source vertex. DFS(int s) traverses vertices  ` `# reachable from s.  ` ` `  `# This class represents a directed graph using adjacency  ` `# list representation  ` `class` `Graph:  ` `    ``def` `__init__(``self``,V): ``# Constructor  ` `        ``self``.V ``=` `V        ``# No. of vertices  ` `        ``self``.adj  ``=` `[[] ``for` `i ``in` `range``(V)]  ``# adjacency lists  ` ` `  `    ``def` `addEdge(``self``,v, w):     ``# to add an edge to graph ` `        ``self``.adj[v].append(w)    ``# Add w to v’s list.  ` ` `  ` `  `    ``# prints all not yet visited vertices reachable from s  ` `    ``def` `DFS(``self``,s):            ``# prints all vertices in DFS manner from a given source. ` `                                ``# Initially mark all verices as not visited  ` `        ``visited ``=` `[``False` `for` `i ``in` `range``(``self``.V)]  ` ` `  `        ``# Create a stack for DFS  ` `        ``stack ``=` `[] ` ` `  `        ``# Push the current source node.  ` `        ``stack.append(s)  ` ` `  `        ``while` `(``len``(stack)):  ` `            ``# Pop a vertex from stack and print it  ` `            ``s ``=` `stack[``-``1``]  ` `            ``stack.pop() ` ` `  `            ``# Stack may contain same vertex twice. So  ` `            ``# we need to print the popped item only  ` `            ``# if it is not visited.  ` `            ``if` `(``not` `visited[s]):  ` `                ``print``(s,end``=``' '``) ` `                ``visited[s] ``=` `True`  ` `  `            ``# Get all adjacent vertices of the popped vertex s  ` `            ``# If a adjacent has not been visited, then push it  ` `            ``# to the stack.  ` `            ``for` `node ``in` `self``.adj[s]:  ` `                ``if` `(``not` `visited[node]):  ` `                    ``stack.append(node)  ` ` `  ` `  ` `  `# Driver program to test methods of graph class  ` ` `  `g ``=` `Graph(``5``); ``# Total 5 vertices in graph  ` `g.addEdge(``1``, ``0``);  ` `g.addEdge(``0``, ``2``);  ` `g.addEdge(``2``, ``1``);  ` `g.addEdge(``0``, ``3``);  ` `g.addEdge(``1``, ``4``);  ` ` `  `print``(``"Following is Depth First Traversal"``)  ` `g.DFS(``0``) ` ` `  `# This code is contributed by ankush_953 `

## C#

 `// An Iterative C# program to do DFS traversal from ` `// a given source vertex. DFS(int s) traverses vertices ` `// reachable from s. ` `using` `System;  ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{ ` `    ``// This class represents a directed graph using adjacency ` `    ``// list representation ` `    ``public` `class` `Graph ` `    ``{ ` `        ``public` `int` `V; ``// Number of Vertices ` `         `  `        ``public` `LinkedList<``int``>[] adj; ``// adjacency lists ` `         `  `        ``// Constructor ` `        ``public` `Graph(``int` `V) ` `        ``{ ` `            ``this``.V = V; ` `            ``adj = ``new` `LinkedList<``int``>[V]; ` `             `  `            ``for` `(``int` `i = 0; i < adj.Length; i++) ` `                ``adj[i] = ``new` `LinkedList<``int``>(); ` `             `  `        ``} ` `         `  `        ``// To add an edge to graph ` `        ``public` `void` `addEdge(``int` `v, ``int` `w) ` `        ``{ ` `            ``adj[v].AddLast(w); ``// Add w to v’s list. ` `        ``} ` `         `  `        ``// prints all not yet visited vertices reachable from s ` `        ``public` `void` `DFS(``int` `s) ` `        ``{ ` `            ``// Initially mark all vertices as not visited ` `            ``Boolean []visited = ``new` `Boolean[V]; ` `                 `  `            ``// Create a stack for DFS ` `            ``Stack<``int``> stack = ``new` `Stack<``int``>(); ` `             `  `            ``// Push the current source node ` `            ``stack.Push(s); ` `             `  `            ``while``(stack.Count > 0) ` `            ``{ ` `                ``// Pop a vertex from stack and print it ` `                ``s = stack.Peek(); ` `                ``stack.Pop(); ` `                 `  `                ``// Stack may contain same vertex twice. So ` `                ``// we need to print the popped item only ` `                ``// if it is not visited. ` `                ``if``(visited[s] == ``false``) ` `                ``{ ` `                    ``Console.Write(s + ``" "``); ` `                    ``visited[s] = ``true``; ` `                ``} ` `                 `  `                ``// Get all adjacent vertices of the popped vertex s ` `                ``// If a adjacent has not been visited, then push it ` `                ``// to the stack. ` `                ``foreach``(``int` `v ``in` `adj[s]) ` `                ``{ ` `                    ``if``(!visited[v]) ` `                        ``stack.Push(v); ` `                ``} ` `                 `  `            ``} ` `        ``} ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String []args)  ` `    ``{ ` `        ``// Total 5 vertices in graph ` `        ``Graph g = ``new` `Graph(5); ` `         `  `        ``g.addEdge(1, 0); ` `        ``g.addEdge(0, 2); ` `        ``g.addEdge(2, 1); ` `        ``g.addEdge(0, 3); ` `        ``g.addEdge(1, 4); ` `             `  `        ``Console.Write(``"Following is the Depth First Traversal\n"``); ` `        ``g.DFS(0); ` `    ``} ` `} ` ` `  `// This code is contributed by Arnasb Kundu `

Output:

```Following is Depth First Traversal
0 3 2 1 4 ```
• Complexity Analysis:

• Time complexity: O(V + E), where V is the number of vertices and E is the number of edges in the graph.
• Space Complexity: O(V). Since an extra visited array is needed of size V.

Modifiation of the above Solution: Note that the above implementation prints only vertices that are reachable from a given vertex. For example, if the edges 0-3 and 0-2 are removed, then the above program would only print 0. To print all vertices of a graph, call DFS for every unvisited vertex.

Implementation:

## C++

 `// An Iterative C++ program to do DFS traversal from ` `// a given source vertex. DFS(int s) traverses vertices ` `// reachable from s. ` `#include ` `using` `namespace` `std; ` ` `  `// This class represents a directed graph using adjacency ` `// list representation ` `class` `Graph ` `{ ` `    ``int` `V;    ``// No. of vertices ` `    ``list<``int``> *adj;    ``// adjacency lists ` `public``: ` `    ``Graph(``int` `V);  ``// Constructor ` `    ``void` `addEdge(``int` `v, ``int` `w); ``// to add an edge to graph ` `    ``void` `DFS();  ``// prints all vertices in DFS manner ` ` `  `    ``// prints all not yet visited vertices reachable from s ` `    ``void` `DFSUtil(``int` `s, vector<``bool``> &visited); ` `}; ` ` `  `Graph::Graph(``int` `V) ` `{ ` `    ``this``->V = V; ` `    ``adj = ``new` `list<``int``>[V]; ` `} ` ` `  `void` `Graph::addEdge(``int` `v, ``int` `w) ` `{ ` `    ``adj[v].push_back(w); ``// Add w to v’s list. ` `} ` ` `  `// prints all not yet visited vertices reachable from s ` `void` `Graph::DFSUtil(``int` `s, vector<``bool``> &visited) ` `{ ` `    ``// Create a stack for DFS ` `    ``stack<``int``> stack; ` ` `  `    ``// Push the current source node. ` `    ``stack.push(s); ` ` `  `    ``while` `(!stack.empty()) ` `    ``{ ` `        ``// Pop a vertex from stack and print it ` `        ``s = stack.top(); ` `        ``stack.pop(); ` ` `  `        ``// Stack may contain same vertex twice. So ` `        ``// we need to print the popped item only ` `        ``// if it is not visited. ` `        ``if` `(!visited[s]) ` `        ``{ ` `            ``cout << s << ``" "``; ` `            ``visited[s] = ``true``; ` `        ``} ` ` `  `        ``// Get all adjacent vertices of the popped vertex s ` `        ``// If a adjacent has not been visited, then push it ` `        ``// to the stack. ` `        ``for` `(``auto` `i = adj[s].begin(); i != adj[s].end(); ++i) ` `            ``if` `(!visited[*i]) ` `                ``stack.push(*i); ` `    ``} ` `} ` ` `  `// prints all vertices in DFS manner ` `void` `Graph::DFS() ` `{ ` `    ``// Mark all the vertices as not visited ` `    ``vector<``bool``> visited(V, ``false``); ` ` `  `    ``for` `(``int` `i = 0; i < V; i++) ` `        ``if` `(!visited[i]) ` `            ``DFSUtil(i, visited); ` `} ` ` `  `// Driver program to test methods of graph class ` `int` `main() ` `{ ` `    ``Graph g(5);  ``// Total 5 vertices in graph ` `    ``g.addEdge(1, 0); ` `    ``g.addEdge(2, 1); ` `    ``g.addEdge(3, 4); ` `    ``g.addEdge(4, 0); ` ` `  `    ``cout << ``"Following is Depth First Traversal\n"``; ` `    ``g.DFS(); ` ` `  `    ``return` `0; ` `} `

## Java

 `//An Iterative Java program to do DFS traversal from ` `//a given source vertex. DFS() traverses vertices ` `//reachable from s. ` ` `  `import` `java.util.*; ` ` `  `public` `class` `GFG  ` `{ ` `    ``// This class represents a directed graph using adjacency ` `    ``// list representation ` `    ``static` `class` `Graph ` `    ``{ ` `        ``int` `V; ``//Number of Vertices ` `         `  `        ``LinkedList[] adj; ``// adjacency lists ` `         `  `        ``//Constructor ` `        ``Graph(``int` `V) ` `        ``{ ` `            ``this``.V = V; ` `            ``adj = ``new` `LinkedList[V]; ` `             `  `            ``for` `(``int` `i = ``0``; i < adj.length; i++) ` `                ``adj[i] = ``new` `LinkedList(); ` `             `  `        ``} ` `         `  `        ``//To add an edge to graph ` `        ``void` `addEdge(``int` `v, ``int` `w) ` `        ``{ ` `            ``adj[v].add(w); ``// Add w to v’s list. ` `        ``} ` `         `  `        ``// prints all not yet visited vertices reachable from s ` `        ``void` `DFSUtil(``int` `s, Vector visited) ` `        ``{ ` `            ``// Create a stack for DFS ` `            ``Stack stack = ``new` `Stack<>(); ` `              `  `            ``// Push the current source node ` `            ``stack.push(s); ` `              `  `            ``while``(stack.empty() == ``false``) ` `            ``{ ` `                ``// Pop a vertex from stack and print it ` `                ``s = stack.peek(); ` `                ``stack.pop(); ` `                  `  `                ``// Stack may contain same vertex twice. So ` `                ``// we need to print the popped item only ` `                ``// if it is not visited. ` `                ``if``(visited.get(s) == ``false``) ` `                ``{ ` `                    ``System.out.print(s + ``" "``); ` `                    ``visited.set(s, ``true``); ` `                ``} ` `                  `  `                ``// Get all adjacent vertices of the popped vertex s ` `                ``// If a adjacent has not been visited, then push it ` `                ``// to the stack. ` `                ``Iterator itr = adj[s].iterator(); ` `                  `  `                ``while` `(itr.hasNext())  ` `                ``{ ` `                    ``int` `v = itr.next(); ` `                    ``if``(!visited.get(v)) ` `                        ``stack.push(v); ` `                ``} ` `                  `  `            ``} ` `        ``} ` `         `  `        ``// prints all vertices in DFS manner ` `        ``void` `DFS() ` `        ``{ ` `            ``Vector visited = ``new` `Vector(V); ` `            ``// Mark all the vertices as not visited ` `            ``for` `(``int` `i = ``0``; i < V; i++) ` `                ``visited.add(``false``); ` `     `  `            ``for` `(``int` `i = ``0``; i < V; i++) ` `                ``if` `(!visited.get(i)) ` `                    ``DFSUtil(i, visited); ` `        ``}     ` `    ``} ` `     `  `    ``// Driver program to test methods of graph class ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``Graph g = ``new` `Graph(``5``); ` `        ``g.addEdge(``1``, ``0``); ` `        ``g.addEdge(``2``, ``1``); ` `        ``g.addEdge(``3``, ``4``); ` `        ``g.addEdge(``4``, ``0``); ` `          `  `        ``System.out.println(``"Following is Depth First Traversal"``); ` `        ``g.DFS(); ` `    ``} ` `} `

## Python3

 `# An Iterative Python 3 program to do DFS  ` `# traversal from a given source vertex.  ` `# DFS(s) traverses vertices reachable from s. ` `class` `Graph:  ` `    ``def` `__init__(``self``, V): ` `        ``self``.V ``=` `V  ` `        ``self``.adj ``=` `[[] ``for` `i ``in` `range``(V)] ` `     `  `    ``def` `addEdge(``self``, v, w): ` `        ``self``.adj[v].append(w) ``# Add w to v’s list. ` `     `  `    ``# prints all not yet visited vertices  ` `    ``# reachable from s  ` `    ``def` `DFSUtil(``self``, s, visited): ` `         `  `        ``# Create a stack for DFS  ` `        ``stack ``=` `[] ` `     `  `        ``# Push the current source node.  ` `        ``stack.append(s)  ` `     `  `        ``while` `(``len``(stack) !``=` `0``): ` `             `  `            ``# Pop a vertex from stack and print it  ` `            ``s ``=` `stack.pop() ` `     `  `            ``# Stack may contain same vertex twice.  ` `            ``# So we need to prthe popped item only  ` `            ``# if it is not visited.  ` `            ``if` `(``not` `visited[s]): ` `                ``print``(s, end ``=` `" "``)  ` `                ``visited[s] ``=` `True` `     `  `            ``# Get all adjacent vertices of the  ` `            ``# popped vertex s. If a adjacent has not   ` `            ``# been visited, then push it to the stack. ` `            ``i ``=` `0` `            ``while` `i < ``len``(``self``.adj[s]): ` `                ``if` `(``not` `visited[``self``.adj[s][i]]):  ` `                    ``stack.append(``self``.adj[s][i]) ` `                ``i ``+``=` `1` `     `  `    ``# prints all vertices in DFS manner  ` `    ``def` `DFS(``self``): ` `         `  `        ``# Mark all the vertices as not visited  ` `        ``visited ``=` `[``False``] ``*` `self``.V ` `        ``for` `i ``in` `range``(``self``.V): ` `            ``if` `(``not` `visited[i]): ` `                ``self``.DFSUtil(i, visited) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``g ``=` `Graph(``5``) ``# Total 5 vertices in graph  ` `    ``g.addEdge(``1``, ``0``)  ` `    ``g.addEdge(``2``, ``1``)  ` `    ``g.addEdge(``3``, ``4``)  ` `    ``g.addEdge(``4``, ``0``)  ` ` `  `    ``print``(``"Following is Depth First Traversal"``)  ` `    ``g.DFS() ` ` `  `# This code is contributed by PranchalK `

## C#

 `// An Iterative C# program to do DFS traversal from ` `// a given source vertex. DFS() traverses vertices ` `// reachable from s. ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{ ` `    ``// This class represents a directed graph using adjacency ` `    ``// list representation ` `    ``class` `Graph ` `    ``{ ` `        ``public` `int` `V; ``// Number of Vertices ` `         `  `        ``public` `List<``int``>[] adj; ``// adjacency lists ` `         `  `        ``// Constructor ` `        ``public` `Graph(``int` `V) ` `        ``{ ` `            ``this``.V = V; ` `            ``adj = ``new` `List<``int``>[V]; ` `             `  `            ``for` `(``int` `i = 0; i < adj.Length; i++) ` `                ``adj[i] = ``new` `List<``int``>(); ` `             `  `        ``} ` `         `  `        ``// To add an edge to graph ` `        ``public` `void` `addEdge(``int` `v, ``int` `w) ` `        ``{ ` `            ``adj[v].Add(w); ``// Add w to v’s list. ` `        ``} ` `         `  `        ``// prints all not yet visited vertices reachable from s ` `        ``public` `void` `DFSUtil(``int` `s, List visited) ` `        ``{ ` `            ``// Create a stack for DFS ` `            ``Stack<``int``> stack = ``new` `Stack<``int``>(); ` `             `  `            ``// Push the current source node ` `            ``stack.Push(s); ` `             `  `            ``while``(stack.Count != 0) ` `            ``{ ` `                ``// Pop a vertex from stack and print it ` `                ``s = stack.Peek(); ` `                ``stack.Pop(); ` `                 `  `                ``// Stack may contain same vertex twice. So ` `                ``// we need to print the popped item only ` `                ``// if it is not visited. ` `                ``if``(visited[s] == ``false``) ` `                ``{ ` `                    ``Console.Write(s + ``" "``); ` `                    ``visited[s] = ``true``; ` `                ``} ` `                 `  `                ``// Get all adjacent vertices of the popped vertex s ` `                ``// If a adjacent has not been visited, then push it ` `                ``// to the stack. ` `                ``foreach``(``int` `itr ``in` `adj[s])  ` `                ``{ ` `                    ``int` `v = itr; ` `                    ``if``(!visited[v]) ` `                        ``stack.Push(v); ` `                ``} ` `                 `  `            ``} ` `        ``} ` `         `  `        ``// prints all vertices in DFS manner ` `        ``public` `void` `DFS() ` `        ``{ ` `            ``List visited = ``new` `List(V); ` `             `  `            ``// Mark all the vertices as not visited ` `            ``for` `(``int` `i = 0; i < V; i++) ` `                ``visited.Add(``false``); ` `     `  `            ``for` `(``int` `i = 0; i < V; i++) ` `                ``if` `(!visited[i]) ` `                    ``DFSUtil(i, visited); ` `        ``}  ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``Graph g = ``new` `Graph(5); ` `        ``g.addEdge(1, 0); ` `        ``g.addEdge(2, 1); ` `        ``g.addEdge(3, 4); ` `        ``g.addEdge(4, 0); ` `         `  `        ``Console.WriteLine(``"Following is Depth First Traversal"``); ` `        ``g.DFS(); ` `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```Following is Depth First Traversal
0 1 2 3 4```

Like recursive traversal, the time complexity of iterative implementation is O(V + E).

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

20

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.