What is the difference between Backtracking and Recursion?

What is Recursion?

The process in which a function calls itself directly or indirectly is called recursion and the corresponding function is called a recursive function.

Real Life Example

Imagine we have a set of boxes, each containing a smaller box. To find an item, we open the outermost box and continue opening the next inner one until we reach the smallest box. Once we find the item or reach the end, we close the boxes in reverse order.
This resembles recursion, where we solve a problem by breaking it into smaller subproblems until we hit a base case, then return results back through the previous layers.

Properties of Recursion:

• Performing the same operations multiple times with different inputs.
• In every step, we try smaller inputs to make the problem smaller.
• A base condition is needed to stop the recursion otherwise infinite loop will occur.

What is Backtracking?

Backtracking is an algorithmic technique for solving problems recursively by trying to build a solution incrementally, one piece at a time, removing those solutions that fail to satisfy the constraints of the problem at any point in time (by time, here, is referred to the time elapsed till reaching any level of the search tree). 

Backtracking can be defined as a general algorithmic technique that considers searching every possible combination in order to solve a computational problem.

Real Life Example

Think of navigating a maze. At each turn, we choose a path. If we reach a dead end, we go back to the previous turn and try a different route. We repeat this until we find the way out.
This models backtracking, where we make a series of decisions, and if a choice leads to a failure, we backtrack to try other possible paths. It’s recursion with an added layer of pruning invalid choices.

There are three types of problems in backtracking:  

• Decision Problem – In this, we search for a feasible solution.
• Optimization Problem – In this, we search for the best solution.
• Enumeration Problem – In this, we find all feasible solutions.

What is the difference between Backtracking and Recursion?

When to use Recursion or Backtracking?

Use Recursion When:

• The problem can be naturally broken down into smaller subproblems.
• The result of a problem depends on the results of smaller instances of the same problem.
• The problem follows a divide and conquer strategy, such as breaking the input into halves or parts recursively.

Examples:

• Merge Sort / Quick Sort (divide array, sort, and combine)
• Binary Search (dividing search space)
• Tree and Graph Traversals (inorder, preorder, postorder)
• Mathematical functions (factorial, Fibonacci)

Use Backtracking When:

• The problem requires exploring all possible combinations or arrangements.
• You must try, test, and revert (undo) choices that lead to dead ends (i.e., invalid states).
• There are constraints involved, and not all paths need to be explored if a certain condition fails early.
• The solution involves constructing partial candidates and pruning those that don’t satisfy the condition.

Examples:

• N-Queens Problem (placing queens such that they don’t attack)
• Sudoku Solver (filling numbers satisfying rules)
• Subset Sum / Combinations / Permutations
• Maze Solving / Word Search (path-finding with constraints)

Related Articles:

• Introduction to Recursion - Data Structures and Algorithms Tutorials
• Introduction to Backtracking - Data Structures and Algorithms Tutorials