Iterative Depth First Traversal of Graph - GeeksforGeeks

26 Nov, 2021
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: Created a stack of nodes and visited array.Insert the root in the stack.Run a loop till the stack is not empty.Pop the element from the stack and print the element.For every adjacent and unvisited node of current node, mark the node and insert it in the stack.
Created a stack of nodes and visited array.Insert the root in the stack.Run a loop till the stack is not empty.Pop the element from the stack and print the element.For every adjacent and unvisited node of current node, mark the node and insert it in the stack.
Created a stack of nodes and visited array.
Insert the root in the stack.
Run a loop till the stack is not empty.
Pop the element from the stack and print the element.
For every adjacent and unvisited 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++
Java
Python3
C#
Javascript
// An Iterative C++ program to do DFS traversal from// a given source vertex. DFS(int s) traverses vertices// reachable from s.#include<bits/stdc++.h>using namespace std; // This class represents a directed graph using adjacency// list representationclass Graph{    int V;    // No. of vertices    list<int> *adj;    // adjacency listspublic:    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 svoid Graph::DFS(int s){    // Initially mark all vertices 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        int 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 classint 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;}
//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<Integer>[] 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<Integer>();                     }                 //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<Boolean> visited = new Vector<Boolean>(V);            for (int i = 0; i < V; i++)                visited.add(false);                 // Create a stack for DFS            Stack<Integer> 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<Integer> 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);    }}
# 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 representationclass 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 vertices 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 graphg.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
// 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
<script> // An Iterative Javascript 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 representationclass Graph{     constructor(V){    this.V = V;    this.adj = new Array(V);         for(let i = 0; i < this.adj.length; i++)        this.adj[i] = [];} // To add an edge to graphaddEdge(v, w){         // Add w to v’s list.    this.adj[v].push(w);} // Prints all not yet visited// vertices reachable from sDFS(s){         // Initially mark all vertices as not visited    let visited = [];    for(let i = 0; i < this.V; i++)        visited.push(false);     // Create a stack for DFS    let stack = [];          // Push the current source node    stack.push(s);          while(stack.length != 0)    {                 // Pop a vertex from stack and print it        s = 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)        {            document.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.        for(let node = 0;                node < this.adj[s].length;                node++)        {            if (!visited[this.adj[s][node]])                stack.push(this.adj[s][node])        }    }}} // Driver code // Total 5 vertices in graphlet g = new Graph(5);g.addEdge(1, 0);g.addEdge(0, 2);g.addEdge(2, 1);g.addEdge(0, 3);g.addEdge(1, 4); document.write("Following is the Depth " +               "First Traversal<br>");g.DFS(0); // This code is contributed by rag2127 </script>
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.
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.
Modification 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++
Java
Python3
C#
Javascript
// An Iterative C++ program to do DFS traversal from// a given source vertex. DFS(int s) traverses vertices// reachable from s.#include<bits/stdc++.h>using namespace std; // This class represents a directed graph using adjacency// list representationclass Graph{    int V;    // No. of vertices    list<int> *adj;    // adjacency listspublic:    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 svoid 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        int 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 mannervoid 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 classint 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;}
//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<Integer>[] 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<Integer>();                     }                 //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<Boolean> visited)        {            // Create a stack for DFS            Stack<Integer> 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<Integer> 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<Boolean> visited = new Vector<Boolean>(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();    }}
# An Iterative Python3 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 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.            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 Codeif __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
// 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<Boolean> 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<Boolean> visited = new List<Boolean>(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
<script>//An Iterative Javascript program to do DFS traversal from//a given source vertex. DFS() traverses vertices//reachable from s. // This class represents a directed graph using adjacency    // list representationclass Graph{     //Constructor    constructor(V)    {        this.V=V;        this.adj = new Array(V);        for (let i = 0; i < this.adj.length; i++)                this.adj[i] = [];    }         //To add an edge to graph    addEdge(v,w)    {        this.adj[v].push(w); // Add w to v’s list.    }          // prints all not yet visited vertices reachable from s    DFSUtil(s,visited)    {        // Create a stack for DFS            let stack = [];                           // Push the current source node            stack.push(s);                           while(stack.length != 0)            {                // Pop a vertex from stack and print it                s = 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)                {                    document.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.                                                    for (let itr=0;itr<this.adj[s].length;itr++)                {                    let v = this.adj[s][itr];                    if(!visited[v])                        stack.push(v);                }                               }    }         // prints all vertices in DFS manner    DFS()    {        let visited = []            // Mark all the vertices as not visited            for (let i = 0; i < this.V; i++)                visited.push(false);                  for (let i = 0; i < this.V; i++)                if (!visited[i])                    this.DFSUtil(i, visited);                }     } // Driver program to test methods of graph classlet g = new Graph(5);g.addEdge(1, 0);g.addEdge(2, 1);g.addEdge(3, 4);g.addEdge(4, 0); document.write("Following is Depth First Traversal<br>");g.DFS();   // This code is contributed by avanitrachhadiya2155</script>
Output: 
Following is Depth First Traversal
0 1 2 3 4
Like recursive traversal, the time complexity of iterative implementation is O(V + E). 
This article is contributed by Shivam. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
PranchalKatiyar
ankush_953
the_alphaEye
nidhi_biet
andrew1234
29AjayKumar
abhinavgalodha
ashishkaushik53552
rag2127
avanitrachhadiya2155
vishalthoke2
varshagumber28
Kirti_Mangal
DFS
Graph
Stack
Stack
DFS
Graph
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
Topological Sorting
Detect Cycle in a Directed Graph
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16
Stack Data Structure (Introduction and Program)
Stack Class in Java
Stack in Python
Check for Balanced Brackets in an expression (well-formedness) using Stack
Stack | Set 2 (Infix to Postfix)