The ultimate recursion guide! Master basics, solve real-world problems, and get interview-ready in hours with FAANG engineers’ proven strategies.

If you’ve ever struggled with solving coding problems using recursion, or if you need to brush up your recursion skills for an interview, this course is for you! We will start with the basics of recursion before we practice solving actual coding problems. You’ll have access to detailed explanations and visualizations for each problem to help you along the way.

By the time you have completed this course, you’ll be able to use all the concepts of recursion to solve complex, real-world problems. We hope that this course will help you ace all the recursion related questions during interviews at top tech companies!

Recursion for Coding Interviews in Python

from collections import defaultdict 
class Graph:

  # Constructor
  def __init__(self, vertices):
    self.graph = defaultdict(list)
    self.vertices = vertices
    
  def addEdge(self, u, v):
    self.graph[u].append(v) 

import graph as g

def helperFunction(myGraph, currentNode, visited, result) :
  visited[currentNode] = True # Mark the current node as visited
  
  # Recur for all the adjacent vertices of currentNode
  for i in myGraph.graph[currentNode] :
    if visited[i] == False :
      helperFunction(myGraph, i, visited, result)
  
  result.insert(0, currentNode) # Push current vertex to result
  
  
def topologicalSort(myGraph) :
  visited = [False] * myGraph.vertices  # Mark all the vertices as not visited
  result = [] # Our stack to store the result/output

  for currentNode in range(myGraph.vertices) :
    if visited[currentNode] == False :
      helperFunction(myGraph, currentNode, visited, result)

  return(result)


# Driver code 
# Create a graph given in the above diagram 
myGraph = g.Graph(5) 
myGraph.addEdge(0, 1) 
myGraph.addEdge(0, 3) 
myGraph.addEdge(1, 2) 
myGraph.addEdge(2, 3) 
myGraph.addEdge(2, 4) 
myGraph.addEdge(3, 4) 

print("Topological Sort")
print(topologicalSort(myGraph))

## Explanation
We traverse the given graph beginning with the first node. Since the first node has not been marked **visited** yet, we call the `helperFunction()` for it. In the `helperFunction()`, this node is marked as **visited**, and we then recursively call the `helperFunction()` for its **adjacent but unvisited** vertices.

In topological sorting, we use a temporary stack, `result`. We print the vertex after its adjacent vertices have all been visited. Each adjacent vertex implies that this task needs to be performed before the current task. Here, the stack data structure helps to keep that order

> A vertex is pushed to the stack only when all of its adjacent vertices are already in the stack.

Let's have a look at the algorithm to solve this problem:
```python
def helperFunction(u)
    # mark u visited
    for each vertex i with an edge from u to i
        helperFunction(i)

    # push u to head of result

def topologicalSort(graph)

  result ← The empty stack that will contain the sorted vertices

  while there are unvisited vertices do : 
      # select an unvisited vertex currentNode
        helperFunction(currentNode)

return(result)
```
​
The pseudocode can be mapped to the visualization below:

This review provides a detailed analysis of the solution to topologically sort a graph.



Recursion Fundamentals

Iteration Vs. Recursion

Recursion with Numbers

Recursion with Strings

Recursion with Arrays

Recursion with Data Structures

Conclusion

Solution Review 3: Topological Sorting of a Graph

Solution: Using Recursion

Explanation