- Published on

# Solving the Tower of Hanoi with C#

- Authors
- Name
- Martin Staael
- @staael

**Solving the Tower of Hanoi**

Recursion is a fundamental concept in computer science and an essential tool for solving complex problems efficiently. One of the most interesting problems that demonstrates recursion is the **Tower of Hanoi**. In this article, we'll explore how recursion works and implement a recursive solution in C# to solve the Tower of Hanoi puzzle.

**What is the Tower of Hanoi?**

The Tower of Hanoi puzzle consists of three rods and a number of disks of different sizes. Initially, all the disks are stacked on the first rod in increasing size, with the smallest disk on top. The objective is to move all the disks to the third rod following these rules:

- Only one disk can be moved at a time.
- You can only move the top disk of any rod.
- No disk may be placed on top of a smaller disk.

The puzzle seems simple, but as the number of disks increases, it becomes more challenging. This is where recursion shines.

**The Recursive Approach**

To solve this problem recursively, let's break it down into smaller problems:

- Move
`n-1`

disks from the source rod to the auxiliary rod. - Move the
`nth`

(largest) disk to the destination rod. - Move the
`n-1`

disks from the auxiliary rod to the destination rod.

By repeating this process, we solve the entire puzzle. The base case for recursion is when there's only one disk, which can be moved directly from the source to the destination.

**C# Implementation of the Tower of Hanoi**

Let’s implement this solution in C#. We'll write a recursive function to solve the Tower of Hanoi problem for any given number of disks.

```
using System;
class TowerOfHanoi
{
// Recursive method to solve the Tower of Hanoi problem
static void SolveHanoi(int numDisks, char source, char destination, char auxiliary)
{
// Base case: if there's only one disk, move it directly from source to destination
if (numDisks == 1)
{
Console.WriteLine($"Move disk 1 from {source} to {destination}");
return;
}
// Step 1: Move n-1 disks from source to auxiliary
SolveHanoi(numDisks - 1, source, auxiliary, destination);
// Step 2: Move the nth (largest) disk to the destination
Console.WriteLine($"Move disk {numDisks} from {source} to {destination}");
// Step 3: Move the n-1 disks from auxiliary to destination
SolveHanoi(numDisks - 1, auxiliary, destination, source);
}
static void Main()
{
// Number of disks
int numDisks = 3;
// Solve the puzzle
SolveHanoi(numDisks, 'A', 'C', 'B');
}
}
```

**How the Code Works**

: This is the recursive function that solves the puzzle. It takes the number of disks, and three characters representing the source, destination, and auxiliary rods.`SolveHanoi`

Method- The base case checks if there's only one disk. If true, it directly moves that disk from the source to the destination.
- If there are more than one disk, the method recursively moves the
`n-1`

disks from the source to the auxiliary rod, then moves the largest disk, and finally moves the remaining`n-1`

disks to the destination.

**Main Method**: Here, we define the number of disks (`numDisks = 3`

) and call the`SolveHanoi`

method to solve the puzzle, moving all disks from rod 'A' to rod 'C' using rod 'B' as the auxiliary.

**Recursion in Action**

When the program runs, the recursive function breaks the problem into smaller parts, progressively moving smaller stacks of disks. For example, with 3 disks, the output would look like this:

```
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
```

Each recursive call simplifies the problem until it reaches the base case where only one disk is moved, after which it resolves the remaining recursive steps.

**Why Recursion is Effective**

Recursion is particularly well-suited for problems like the Tower of Hanoi because the problem naturally divides into smaller sub-problems. Each sub-problem mirrors the structure of the larger problem, making recursion a clean and elegant solution.

Recursion also makes the code simpler and easier to understand once you grasp the concept. Instead of using complex loops or keeping track of multiple states, recursion handles the logic intuitively by calling itself with a reduced problem size.

**Challenges of Recursion**

While recursion is powerful, it can lead to issues if not used carefully:

**Stack overflow**: Recursive calls consume stack memory, and too many recursive calls can lead to a stack overflow. This is particularly problematic for large inputs.**Efficiency**: Recursive solutions can sometimes be less efficient due to repeated calculations. However, for problems like the Tower of Hanoi, the recursive approach is optimal.

**Conclusion**

The Tower of Hanoi puzzle is a perfect example to illustrate recursion in C#. Through this problem, we can see how recursion breaks down a complex problem into smaller, more manageable parts. While recursion can seem tricky at first, it's a powerful tool when applied correctly. Understanding and mastering recursion is crucial for every software engineer, and problems like the Tower of Hanoi are a great way to start.

Try experimenting with the number of disks in the code, and watch how recursion handles the challenge efficiently!