DFS Traversal - Problem

Implement depth-first search (DFS) traversal for a graph using both iterative (stack-based) and recursive approaches.

Given an adjacency list representation of an undirected graph and a starting vertex, return a list of vertices visited in DFS order. If multiple neighbors exist, visit them in ascending numerical order.

Requirements:

Implement both iterative and recursive versions
Return vertices in the order they are first visited
Handle disconnected components (only traverse from the given start vertex)
Visit neighbors in ascending order for consistent output

Input & Output

Example 1 — Connected Graph

$ Input: graph = {"0": [1, 2], "1": [0, 3, 4], "2": [0, 5], "3": [1], "4": [1], "5": [2]}, start = 0

› Output: [0,1,3,4,2,5]

💡 Note: Starting from node 0, visit neighbors 1 and 2. From node 1, visit neighbors 3 and 4. From node 2, visit neighbor 5. All nodes are reachable.

Example 2 — Partial Graph

$ Input: graph = {"0": [1], "1": [0, 2], "2": [1], "3": [4], "4": [3]}, start = 0

› Output: [0,1,2]

💡 Note: Starting from node 0, can only reach nodes 1 and 2. Nodes 3 and 4 form a separate component and are not reachable from 0.

Example 3 — Single Node

$ Input: graph = {"0": []}, start = 0

› Output: [0]

💡 Note: Single isolated node with no neighbors. DFS returns just the starting node.

Constraints

1 ≤ number of nodes ≤ 1000
0 ≤ number of edges ≤ 2000
Graph is represented as adjacency list with string keys
All node values are non-negative integers

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is that DFS explores as deep as possible before backtracking, which can be implemented either recursively (using call stack) or iteratively (using explicit stack). Best approach depends on graph depth: recursive for typical cases, iterative for very deep graphs. Time: O(V + E), Space: O(V).

Common Approaches

✓ Iterative DFS with Stack

⏱️ Time: O(V + E) Space: O(V)

Uses an explicit stack data structure to manage nodes to visit. Push neighbors onto stack and pop to get next node to explore, avoiding recursion depth issues.

Recursive DFS

⏱️ Time: O(V + E) Space: O(V + h)

Uses the call stack implicitly for DFS traversal. Mark each node as visited and recursively explore all unvisited neighbors in sorted order.

Iterative DFS with Stack — Algorithm Steps

Step 1: Initialize stack with starting node and visited set
Step 2: Pop node from stack, mark as visited, add to result
Step 3: Push all unvisited neighbors onto stack in reverse order
Step 4: Repeat until stack is empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Push

Push starting node onto stack

Pop & Visit

Pop node, mark visited, push unvisited neighbors

Repeat

Continue until stack is empty

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_NODES 1000
#define MAX_NEIGHBORS 100
#define MAX_STACK 1000

int graph[MAX_NODES][MAX_NEIGHBORS];
int graph_sizes[MAX_NODES];
bool visited[MAX_NODES];
int result[MAX_NODES];
int result_size = 0;
int stack[MAX_STACK];
int stack_size = 0;

int compare_reverse(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

int* solution(int start, int* return_size) {
    memset(visited, false, sizeof(visited));
    result_size = 0;
    stack_size = 0;
    
    // Push start node
    stack[stack_size++] = start;
    
    while (stack_size > 0) {
        // Pop from stack
        int node = stack[--stack_size];
        
        if (!visited[node]) {
            visited[node] = true;
            result[result_size++] = node;
            
            // Sort neighbors in reverse order
            qsort(graph[node], graph_sizes[node], sizeof(int), compare_reverse);
            
            for (int i = 0; i < graph_sizes[node]; i++) {
                int neighbor = graph[node][i];
                if (!visited[neighbor]) {
                    stack[stack_size++] = neighbor;
                }
            }
        }
    }
    
    *return_size = result_size;
    int* ret = malloc(result_size * sizeof(int));
    memcpy(ret, result, result_size * sizeof(int));
    return ret;
}

int main() {
    // Initialize graph
    memset(graph_sizes, 0, sizeof(graph_sizes));
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple JSON parsing for adjacency list
    char *ptr = line;
    while (*ptr) {
        if (*ptr == '"') {
            ptr++;
            int node = atoi(ptr);
            while (*ptr && *ptr != '"') ptr++;
            if (*ptr) ptr++;
            
            // Find the array start
            while (*ptr && *ptr != '[') ptr++;
            if (*ptr) ptr++;
            
            // Parse neighbors
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    int neighbor = atoi(ptr);
                    graph[node][graph_sizes[node]++] = neighbor;
                    while (*ptr >= '0' && *ptr <= '9') ptr++;
                } else {
                    ptr++;
                }
            }
        } else {
            ptr++;
        }
    }
    
    int start;
    scanf("%d", &start);
    
    int return_size;
    int* res = solution(start, &return_size);
    
    printf("[");
    for (int i = 0; i < return_size; i++) {
        if (i > 0) printf(",");
        printf("%d", res[i]);
    }
    printf("]\n");
    
    free(res);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex once and examine each edge once

✓ Linear Growth

Space Complexity

O(V)

Stack and visited set each store at most V vertices

✓ Linear Space

28.5K Views

High Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

DFS Traversal - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Iterative DFS with Stack — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler