Why Tower of Hanoi Problem in DSA C?

The Big Idea

What if a simple rule could solve a puzzle that seems impossible to plan by hand?

The Scenario

Imagine you have three pegs and a stack of different sized disks on one peg. You want to move all disks to another peg, but you can only move one disk at a time and never place a larger disk on top of a smaller one.

Trying to figure out the steps manually for many disks is confusing and easy to mess up.

The Problem

Manually planning each move for many disks is slow and error-prone. You might forget a step or break the rules by placing a bigger disk on a smaller one.

It becomes very hard to keep track of all moves as the number of disks grows.

The Solution

The Tower of Hanoi problem uses a simple set of rules and recursion to break the big problem into smaller ones. This method gives a clear, step-by-step solution that always works, no matter how many disks.

It saves time and avoids mistakes by following a repeatable pattern.

Before vs After

✗ Before

/* Manually list moves for 3 disks */
move disk 1 from A to C
move disk 2 from A to B
move disk 1 from C to B
move disk 3 from A to C
move disk 1 from B to A
move disk 2 from B to C
move disk 1 from A to C

✓ After

void towerOfHanoi(int n, char from, char to, char aux) {
  if (n == 1) {
    printf("Move disk 1 from %c to %c\n", from, to);
    return;
  }
  towerOfHanoi(n-1, from, aux, to);
  printf("Move disk %d from %c to %c\n", n, from, to);
  towerOfHanoi(n-1, aux, to, from);
}

What It Enables

This problem teaches how to solve complex tasks by breaking them into smaller, repeatable steps using recursion.

Real Life Example

Moving boxes between shelves with size limits or organizing tasks where some must be done before others can be solved using the same step-by-step approach.

Key Takeaways

Manual planning is hard and error-prone for many disks.

Recursion breaks the problem into smaller, manageable parts.

The Tower of Hanoi solution is a clear, repeatable method for moving disks correctly.