How does depth-first search work in C++?

Can you explain how depth-first search works in C++?

Sure! Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. It starts at the root (or an arbitrary node) and explores as far as possible along each branch before backtracking.

What data structures do I need to implement DFS?

You typically need a stack to keep track of the nodes to visit next. In C++, you can use the standard library's std::stack or implement your own.

Can you show me a simple C++ code example for DFS?

Certainly! Here's a basic example:

#include <iostream>
#include <vector>
#include <stack>

void DFS(int start, const std::vector<std::vector<int>>& graph) {
    std::stack<int> s;
    std::vector<bool> visited(graph.size(), false);
    s.push(start);

    while (!s.empty()) {
        int node = s.top();
        s.pop();
        if (!visited[node]) {
            visited[node] = true;
            std::cout << node << " ";
            for (int neighbor : graph[node]) {
                if (!visited[neighbor]) {
                    s.push(neighbor);
                }
            }
        }
    }
}

This code performs DFS on a graph represented as an adjacency list.

What are the time and space complexities of DFS?

The time complexity of DFS is O(V + E), where V is the number of vertices and E is the number of edges. The space complexity is O(V) due to the stack used for storing nodes.