Open In App

Program for Tower of Hanoi Algorithm

Tower of Hanoi is a mathematical puzzle where we have three rods (A, B, and C) and N disks. Initially, all the disks are stacked in decreasing value of diameter i.e., the smallest disk is placed on the top and they are on rod A. The objective of the puzzle is to move the entire stack to another rod (here considered C), obeying the following simple rules: 

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 Practice

Tower of Hanoi using Recursion:

 The idea is to use the helper node to reach the destination using recursion. Below is the pattern for this problem:

  • Shift ‘N-1’ disks from ‘A’ to ‘B’, using C.
  • Shift last disk from ‘A’ to ‘C’.
  • Shift ‘N-1’ disks from ‘B’ to ‘C’, using A.

Image illustration for 3 disks

Follow the steps below to solve the problem:

Below is the implementation of the above approach.




// 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 == 0) {
        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 = 3;
  
    // A, B and C are names of rods
    towerOfHanoi(N, 'A', 'C', 'B');
    return 0;
}
  
// This is code is contributed by rathbhupendra




// JAVA recursive function to
// solve tower of hanoi puzzle
import java.io.*;
import java.math.*;
import java.util.*;
class GFG {
    static void towerOfHanoi(int n, char from_rod,
                             char to_rod, char aux_rod)
    {
        if (n == 0) {
            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 code
    public static void main(String args[])
    {
        int N = 3;
  
        // A, B and C are names of rods
        towerOfHanoi(N, 'A', 'C', 'B');
    }
}
  
// This code is contributed by jyoti369




# Recursive Python function to solve tower of hanoi
  
  
def TowerOfHanoi(n, from_rod, to_rod, aux_rod):
    if n == 0:
        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 = 3
  
# A, C, B are the name of rods
TowerOfHanoi(N, 'A', 'C', 'B')
  
# Contributed By Harshit Agrawal




// C# recursive program to solve tower of hanoi puzzle
using System;
class GFG {
    static void towerOfHanoi(int n, char from_rod,
                             char to_rod, char aux_rod)
    {
        if (n == 0) {
            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(String[] args)
    {
        int N = 3;
  
        // A, B and C are names of rods
        towerOfHanoi(N, 'A', 'C', 'B');
    }
}
  
// This code is contributed by shivanisinghss2110




<?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";
}
  
$N = 3;
initPoles($N);
echo "Tower of Hanoi Solution for $numdisks disks: \n\n";
dispPoles();
TOH($N);
  
// This code is contributed by ShreyakChakraborty
?>




<script>
// javascript recursive function to 
// solve tower of hanoi puzzle 
function towerOfHanoi(n, from_rod,  to_rod,  aux_rod)
{
        if (n == 0)
        {
            return;
        }
        towerOfHanoi(n - 1, from_rod, aux_rod, to_rod);
        document.write("Move disk " + n + " from rod " + from_rod +
        " to rod " + to_rod+"<br/>");
        towerOfHanoi(n - 1, aux_rod, to_rod, from_rod);
    }
  
    // Driver code
    var N = 3;
      
    // A, B and C are names of rods
    towerOfHanoi(N, 'A', 'C', 'B');
  
// This code is contributed by gauravrajput1
</script>

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

Time complexity: O(2N), There are two possibilities for every disk. Therefore, 2 * 2 * 2 * . . . * 2(N times) is 2N
Auxiliary Space: O(N), Function call stack space

Related Articles 


Article Tags :