Program for Tower of Hanoi

Tower of Hanoi is a mathematical puzzle where we have three rods and n disks. The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules:
1) Only one disk can be moved at a time.
2) Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
3) No disk may be placed on top of a smaller disk.

Approach :

Take an example for 2 disks :
Let rod 1 = 'A', rod 2 = 'B', rod 3 = 'C'.

Step 1 : Shift first disk from 'A' to 'B'.
Step 2 : Shift second disk from 'A' to 'C'.
Step 3 : Shift first disk from 'B' to 'C'.

The pattern here is :
Shift 'n-1' disks from 'A' to 'B'.
Shift last disk from 'A' to 'C'.
Shift 'n-1' disks from 'B' to 'C'.

Image illustration for 3 disks :

Examples:

Input : 2
Output : Disk 1 moved from A to B
         Disk 2 moved from A to C
         Disk 1 moved from B to C

Input : 3
Output : Disk 1 moved from A to C
         Disk 2 moved from A to B
         Disk 1 moved from C to B
         Disk 3 moved from A to C
         Disk 1 moved from B to A
         Disk 2 moved from B to C
         Disk 1 moved from A to C

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

C++

// C++ recursive function to  
// solve tower of hanoi puzzle  
#include <bits/stdc++.h> 
using namespace std; 
  
void towerOfHanoi(int n, char from_rod, 
                    char to_rod, char aux_rod)  
{  
    if (n == 1)  
    {  
        cout << "Move disk 1 from rod " << from_rod <<  
                            " to rod " << to_rod<<endl;  
        return;  
    }  
    towerOfHanoi(n - 1, from_rod, aux_rod, to_rod);  
    cout << "Move disk " << n << " from rod " << from_rod << 
                                " to rod " << to_rod << endl;  
    towerOfHanoi(n - 1, aux_rod, to_rod, from_rod);  
}  
  
// Driver code 
int main()  
{  
    int n = 4; // Number of disks  
    towerOfHanoi(n, 'A', 'C', 'B'); // A, B and C are names of rods  
    return 0;  
}  
  
// This is code is contributed by rathbhupendra 

C

#include <stdio.h> 
  
// C recursive function to solve tower of hanoi puzzle 
void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod) 
{ 
    if (n == 1) 
    { 
        printf("\n Move disk 1 from rod %c to rod %c", from_rod, to_rod); 
        return; 
    } 
    towerOfHanoi(n-1, from_rod, aux_rod, to_rod); 
    printf("\n Move disk %d from rod %c to rod %c", n, from_rod, to_rod); 
    towerOfHanoi(n-1, aux_rod, to_rod, from_rod); 
} 
  
int main() 
{ 
    int n = 4; // Number of disks 
    towerOfHanoi(n, 'A', 'C', 'B');  // A, B and C are names of rods 
    return 0; 
} 

Java

// Java recursive program to solve tower of hanoi puzzle 
  
class GFG 
{ 
    // Java recursive function to solve tower of hanoi puzzle 
    static void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod) 
    { 
        if (n == 1) 
        { 
            System.out.println("Move disk 1 from rod " +  from_rod + " to rod " + to_rod); 
            return; 
        } 
        towerOfHanoi(n-1, from_rod, aux_rod, to_rod); 
        System.out.println("Move disk " + n + " from rod " +  from_rod + " to rod " + to_rod); 
        towerOfHanoi(n-1, aux_rod, to_rod, from_rod); 
    } 
      
    //  Driver method 
    public static void main(String args[]) 
    { 
        int n = 4; // Number of disks 
        towerOfHanoi(n, 'A', 'C', 'B');  // A, B and C are names of rods 
    } 
} 

Python

# Recursive Python function to solve tower of hanoi 
  
def TowerOfHanoi(n , from_rod, to_rod, aux_rod): 
    if n == 1: 
        print "Move disk 1 from rod",from_rod,"to rod",to_rod 
        return
    TowerOfHanoi(n-1, from_rod, aux_rod, to_rod) 
    print "Move disk",n,"from rod",from_rod,"to rod",to_rod 
    TowerOfHanoi(n-1, aux_rod, to_rod, from_rod) 
          
# Driver code 
n = 4
TowerOfHanoi(n, 'A', 'C', 'B')  
# A, C, B are the name of rods 
  
# Contributed By Harshit Agrawal 

C#

// C# recursive program to solve  
// tower of hanoi puzzle 
using System; 
  
class geek 
{ 
  
    // C# recursive function to solve  
    // tower of hanoi puzzle 
    static void towerOfHanoi(int n, char from_rod,  
                             char to_rod, char aux_rod) 
    { 
        if (n == 1) 
        { 
            Console.WriteLine("Move disk 1 from rod " + from_rod  
                                           + " to rod " + to_rod); 
            return; 
        } 
        towerOfHanoi(n-1, from_rod, aux_rod, to_rod); 
        Console.WriteLine("Move disk " + n + " from rod " 
                          + from_rod + " to rod " + to_rod); 
        towerOfHanoi(n-1, aux_rod, to_rod, from_rod); 
    } 
      
    // Driver method 
    public static void Main() 
    { 
        // Number of disks 
        int n = 4;  
          
        // A, B and C are names of rods 
        towerOfHanoi(n, 'A', 'C', 'B');  
    } 
} 
  
// This code is contributed by Sam007 

PHP

<?php 
//PHP code to solve Tower of Hanoi problem. 
  
// Recursive Function to solve Tower of Hanoi 
function towerOfHanoi($n, $from_rod, $to_rod, $aux_rod) { 
      
    if ($n === 1) { 
    echo ("Move disk 1 from rod $from_rod to rod $to_rod \n"); 
    return; 
    }  
      
    towerOfHanoi($n-1, $from_rod, $aux_rod, $to_rod); 
    echo ("Move disk $n from rod $from_rod to rod $to_rod \n"); 
    towerOfHanoi($n-1, $aux_rod, $to_rod, $from_rod); 
  
} 
  
// Driver code 
  
// number of disks 
$n = 4; 
  
// A, B and C are names of rods 
towerOfHanoi($n, 'A', 'C', 'B'); 
  
// This code is contributed by akash7981  
?> 

Output:

 Move disk 1 from rod A to rod B
 Move disk 2 from rod A to rod C
 Move disk 1 from rod B to rod C
 Move disk 3 from rod A to rod B
 Move disk 1 from rod C to rod A
 Move disk 2 from rod C to rod B
 Move disk 1 from rod A to rod B
 Move disk 4 from rod A to rod C
 Move disk 1 from rod B to rod C
 Move disk 2 from rod B to rod A
 Move disk 1 from rod C to rod A
 Move disk 3 from rod B to rod C
 Move disk 1 from rod A to rod B
 Move disk 2 from rod A to rod C
 Move disk 1 from rod B to rod C

For n disks, total 2ⁿ – 1 moves are required.

eg: For 4 disks 2⁴ – 1 = 15 moves are required.

For n disks, total 2^n-1 function calls are made.

eg: For 4 disks 2^4-1 = 8 function calls are made.

Additionally, we can display contents of all 3 rods at each step to improve visualization

The following code uses stack-like data structure using PHP array along with push() and pop() operations
to actually modify contents at each step

<?php 
  
// Tower of Hanoi (n-disk) algorithm in PHP with Display of Pole/rod  
// Contents the 3 poles representation 
$poles = array(array(), array(), array()); 
  
function TOH($n, $A="A", $B="B", $C="C"){ 
      
    if ($n > 0){ 
        TOH($n-1, $A, $C, $B); 
        echo "Move disk from rod $A to rod $C \n"; 
        move($A, $C); 
        dispPoles(); 
        TOH($n-1, $B, $A, $C); 
    } 
    else { 
        return; 
    } 
} 
  
function initPoles($n){ 
    global $poles; 
  
    for ($i=$n; $i>=1; --$i){ 
        $poles[0][] = $i; 
    } 
} 
  
  
function move($source, $destination){ 
    global $poles; 
      
    // get source and destination pointers 
    if ($source=="A") $ptr1=0; 
    elseif ($source=="B") $ptr1 = 1; 
    else $ptr1 = 2; 
      
    if ($destination=="A") $ptr2 = 0; 
    elseif ($destination=="B") $ptr2 = 1; 
    else $ptr2 = 2; 
      
    $top = array_pop($poles[$ptr1]); 
    array_push($poles[$ptr2], $top); 
} 
  
function dispPoles(){   
    global $poles; 
    echo "A: [".implode(", ", $poles[0])."] "; 
    echo "B: [".implode(", ", $poles[1])."] "; 
    echo "C: [".implode(", ", $poles[2])."] "; 
    echo "\n\n"; 
} 
  
$numdisks = 4; 
initPoles($numdisks); 
echo "Tower of Hanoi Solution for $numdisks disks: \n\n"; 
dispPoles(); 
TOH($numdisks); 
  
// This code is contributed by ShreyakChakraborty 
?> 

Output:

Tower of Hanoi Solution for 4 disks:

A: [4, 3, 2, 1] B: [] C: []

Move disk from rod A to rod B
A: [4, 3, 2] B: [1] C: []

Move disk from rod A to rod C
A: [4, 3] B: [1] C: [2]

Move disk from rod B to rod C
A: [4, 3] B: [] C: [2, 1]

Move disk from rod A to rod B
A: [4] B: [3] C: [2, 1]

Move disk from rod C to rod A
A: [4, 1] B: [3] C: [2]

Move disk from rod C to rod B
A: [4, 1] B: [3, 2] C: []

Move disk from rod A to rod B
A: [4] B: [3, 2, 1] C: []

Move disk from rod A to rod C
A: [] B: [3, 2, 1] C: [4]

Move disk from rod B to rod C
A: [] B: [3, 2] C: [4, 1]

Move disk from rod B to rod A
A: [2] B: [3] C: [4, 1]

Move disk from rod C to rod A
A: [2, 1] B: [3] C: [4]

Move disk from rod B to rod C
A: [2, 1] B: [] C: [4, 3]

Move disk from rod A to rod B
A: [2] B: [1] C: [4, 3]

Move disk from rod A to rod C
A: [] B: [1] C: [4, 3, 2]

Move disk from rod B to rod C
A: [] B: [] C: [4, 3, 2, 1]

Related Articles

References:
http://en.wikipedia.org/wiki/Tower_of_Hanoi

This article is contributed by Rohit Thapliyal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

C++

C

Java

Python

C#

PHP

Additionally, we can display contents of all 3 rods at each step to improve visualization

Recommended Posts: