What are some implementations of depth-first search in different programming languages?

Can you explain depth-first search and provide examples in different programming languages?

Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. It starts at the root and explores as far as possible along each branch before backtracking. Here are examples in a few languages:

1. Python:

   def dfs(graph, node, visited):
       if node not in visited:
           print(node)
           visited.add(node)
           for neighbor in graph[node]:
               dfs(graph, neighbor, visited)
   

2. Java:

   void dfs(Node node) {
       if (node == null) return;
       System.out.println(node.value);
       for (Node neighbor : node.neighbors) {
           dfs(neighbor);
       }
   }
   

3. JavaScript:

   function dfs(node, visited = new Set()) {
       if (!visited.has(node)) {
           console.log(node);
           visited.add(node);
           node.neighbors.forEach(neighbor => dfs(neighbor, visited));
       }
   }
   

What are the differences in syntax and structure between these implementations?

The main differences in syntax and structure among these implementations are:

1. Python uses a simple function definition and a set for visited nodes, making it concise and readable.
2. Java requires class definitions and explicit handling of null values, which adds verbosity but also type safety.
3. JavaScript utilizes a more flexible approach with functions and closures, allowing for dynamic handling of visited nodes using a Set.

Can you provide a more detailed example in C++?

Sure! Here's a depth-first search implementation in C++:

#include <iostream>
#include <vector>
#include <unordered_set>

using namespace std;

void dfs(int node, unordered_set<int>& visited, const vector<vector<int>>& graph) {
    if (visited.find(node) == visited.end()) {
        cout << node << " ";
        visited.insert(node);
        for (int neighbor : graph[node]) {
            dfs(neighbor, visited, graph);
        }
    }
}

int main() {
    vector<vector<int>> graph = {{1, 2}, {0, 3}, {0}, {1}}; // Example graph
    unordered_set<int> visited;
    dfs(0, visited, graph);
    return 0;
}

Thanks! This helps a lot. Can you suggest resources for learning more about graph algorithms?

You're welcome! Here are some great resources to learn more about graph algorithms:

1. Books: "Introduction to Algorithms" by Cormen et al. covers graph algorithms in depth.
2. Online Courses: Coursera and edX offer courses on algorithms that include sections on graph theory.
3. Websites: GeeksforGeeks and LeetCode have extensive articles and problems related to graph algorithms.