top of page

Depth First Search

Depth First Search (DFS)

The DFS algorithm uses the idea of backtracking. It involves exhaustive searches of all the nodes by going ahead, if possible, else by backtracking.

Here, the word backtrack means that when you are moving forward and there are no more nodes along the current path, you move backward on the same path to find nodes to traverse. All the nodes will be visited on the current path until all the unvisited nodes have been traversed after which the next path will be selected.

The basic idea is as follows: 1. Pick a starting node and push all its adjacent nodes into a stack.

2. Pop a node from stack to select the next node to visit and push all its adjacent nodes into a stack. 3. Repeat this process until the stack is empty.

However, ensure that the nodes that are visited are marked. This will prevent you from visiting the same node more than once. If you do not mark the nodes that are visited and you visit the same node more than once, you may end up in an infinite loop.


DFS-iterative (G, s): 
      let S be stack
      S.push( s ) 
      mark s as visited.
      while ( S is not empty):
         v  =  S.top( )
         S.pop( )
        
        for all neighbours w of v in Graph G:
            if w is not visited :
                S.push( w )         
                mark w as visited


DFS-recursive(G, s):
    mark s as visited
    for all neighbours w of s in Graph G:
        if w is not visited:
            DFS-recursive(G, w)

Recent Posts

See All

Linear search

A linear search is used on a collection of items. It relies on the technique of traversing a list from start to end by exploring properties of all the elements that are found on the way. For example,

Comments


bottom of page