how to write recursive DFS scientifically

Principles for Writing Correct Recursive Functions in DFS Algorithms
When implementing a Depth-First Search (DFS) algorithm using recursion, it's crucial to structure your recursive function correctly to ensure it works as intended. Here are the key principles to follow:

1. Start with the Base Case (Exit Condition)
   Purpose: The base case determines when the recursion should stop. It prevents infinite recursion and potential stack overflows.
   Placement: Write the base case at the very beginning of your recursive function.
   Example:

void dfs(Node* node) {
    if (node == nullptr) return; // Base case: exit if node is null
    // Rest of the code
}

2. Process the Current Node
   Purpose: Perform the necessary operations on the current node, such as marking it as visited or processing its value.
   Placement: Typically placed immediately after the base case and before the recursive calls.
   Example:

void dfs(Node* node, unordered_set<Node*>& visited) {
    if (node == nullptr) return; // Base case
    if (visited.count(node)) return; // Avoid revisiting nodes

    visited.insert(node); // Mark as visited
    // Process the node (e.g., print or store its value)
}

3. Make Recursive Calls
   Purpose: Explore adjacent nodes or child nodes by making recursive calls.
   Placement: After processing the current node.
   Example:

void dfs(Node* node, unordered_set<Node*>& visited) {
    if (node == nullptr || visited.count(node)) return; // Base cases

    visited.insert(node); // Process current node

    for (Node* neighbor : node->neighbors) {
        dfs(neighbor, visited); // Recursive call to neighbors
    }
}

4. Order of Writing
   When writing your recursive function:

Base Case First: Always start by defining your exit conditions.
Process Current Node: Handle the current node's processing needs.
Recursive Calls: Finally, proceed to recursive calls to child or adjacent nodes.
5. Avoid Common Pitfalls
Infinite Recursion: Without a proper base case, your function may call itself indefinitely.
Revisiting Nodes: In graphs or trees with cycles, use a visited data structure to prevent processing the same node multiple times.
Stack Overflows: Deep recursion can lead to stack overflows; consider iterative solutions with explicit stacks if necessary.
6. Example: DFS in a Binary Tree

void dfs(TreeNode* node) {
    if (node == nullptr) return; // Base case

    // Process current node
    cout << node->val << " ";

    // Recursive calls
    dfs(node->left);
    dfs(node->right);
}

7. Example: DFS in a Graph with Cycle Detection

void dfs(int node, vector<vector<int>>& graph, vector<bool>& visited) {
    if (visited[node]) return; // Base case to avoid cycles

    visited[node] = true; // Process current node

    for (int neighbor : graph[node]) {
        dfs(neighbor, graph, visited); // Recursive call
    }
}

8. Summary
   Base Case First: Write your exit conditions at the beginning to ensure the recursion terminates.
   Process Before Recursion: Handle the current node's logic before diving deeper.
   Recursive Calls After: Place recursive calls after processing to continue the traversal.
   Consistency: Maintain a consistent structure to make your code readable and maintainable.
   By following these principles, you'll be able to write correct and efficient recursive functions for DFS algorithms. Remember, starting with the base case not only prevents errors but also clarifies the termination condition of your recursion.