How do we approach this?

So, let's take a more practical look at DFS and how we approach it. We want to keep track of the nodes explored and backtrack when we hit a dead-end. Then, we want to take the next node available to us. If there aren't any more, we backtrack again until we find another one, continuing until we find our desired node or until all nodes are explored. To get a better understanding of this, lets take a look at the image below to visualize how this would work.

So, as you can see, we went down 3 nodes starting from A, which is the root node, all the way to D, and we stored all explored nodes in a set. However, we still have 2 unexplored nodes in C and E, so what do we do now?

Well, the last explored node is D, and there doesn’t seem to be anywhere to go from there, so this is where we backtrack to the previous node, which is B. From B, we can see that there is an unexplored node in E.

Great, now that all sub-nodes from B have been explored, we only have C left. So, we backtrack from E to B to A. A's sub-nodes are B and C; we have already explored B, so now we go down to C.

How do we implement DFS in code?

So now that we understand the fundamental idea of Depth-first search, understand that there are 2 ways to implement this:

• Recursive DFS

• Iterative DFS

So both implementations have their pros and cons. Recursive DFS is easier to implement and more readable, but you can run into a problem where the algorithm makes too many recursive calls due to a very large graph, which can crash the program. This is also known as a recursion depth limit.

Now, with Iterative DFS, you will write a bit more code, and it can become complex because you have more control. However, you don’t have the problem of hitting a recursion depth limit, which makes Iterative implementations better for larger graphs.

Now that we know a little bit about the different implementations of DFS, let's take a look at how we can do this using Python:

Recursive DFS

tree = {
    'A': ['B', 'C'],
    'B': ['D', 'E'],
    'C': ['F', 'G'],
    'D': ['H', 'I'],
    'E': ['J', 'K'],
    'F': ['L', 'M'],
    'G': ['N', 'O'],
    'H': [], 'I': [], 'J': [], 'K': [],
    'L': [], 'M': [], 'N': [], 'O': []
}

def recursive_dfs(tree, node, explored=None):
    if explored is None:
        explored = set() # initialize the explored set
    explored.add(node) # add node to set
    print(node) # display the current node
    for n in tree[node]: # visit node in tree
        if n not in explored:
            recursive_dfs(tree, n, explored) # recursive call 

recursive_dfs(tree, "A")

Output

A
B
D
H
I
E
J
K
C
F
L
M
G
N
O

So here we can see that we start at root node “A” and we go all the way down to “O”.

Iterative DFS

def iterative_dfs(tree, start):
    explored = set() # explored nodes
    stack = [start]

    while stack: # Continue until stack is empty
        node = stack.pop() # Pop a node from the stack
        if node not in explored:
            explored.add(node) # add node to set
            print(node) # display current node 
            stack.extend(reversed(tree[node])) # Add sub nodes to stack (reversed() reverses the list)

iterative_dfs(tree, "A")

So you can see the difference in both implementations. In Iterative DFS, we use a stack to keep track of nodes and sub-nodes we need to explore, and when you run both these versions, the same result is returned.

So hopefully you now understand the concept of Depth-first search and how to implement it, there are other aspects of DFS you should understand like the time complexity and some other trade-offs as well, but I just wanted to give you a quick and simple example of what DFS is and how to implement it, I will paste links to other resources that I think will help understand a little bit more.

Other resources

• Big O Notation & Time Complexity

• Depth-first search leetcode

Lets connect

• Follow me on Substack

• Follow me on Twitter/X