Question

During the course, we have seen a recursive implementation for the DFS graph visit. There is also a simple equivalent iterative implementation that uses a stack as an auxiliary data structure (it runs just like the BFS algorithm, except that we use the stack in place of the queue). However, there is an algorithm that iteratively implements the DFS visit and does not use any auxiliary data structure. Design this algorithm and implement it.

Answer 1

As we know Depth First Traversal for a graph is similar to Depth First Traversal (DFS) of a tree. The only difference here is, unlike trees, graphs may contain cycles, so we may come to the same node again. To avoid processing a node more than once, we use a boolean variable visited array.

So the algorithm works in same manner here like :

void Graph::DFS(int s)

{

    // to Initially mark all verices as not visited

    vector<bool> visited(V, false);

  

    // to Create a stack for DFS

    stack<int> stack;

  

    // to Push the current source node.

    stack.push(s);

  

    while (!stack.empty())

    {

        // to Pop a vertex from stack and print it

        s = stack.top();

        stack.pop();

  

        // to 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;

        }

  

        // to 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);

    }

}