Iterative Tower of Hanoi - GeeksforGeeks

25 Feb, 2022
The Tower of Hanoi is a mathematical puzzle. It consists of three poles and a number of disks of different sizes which can slide onto any poles. The puzzle starts with the disk in a neat stack in ascending order of size in one pole, the smallest at the top thus making a conical shape. The objective of the puzzle is to move all the disks from one pole (say ‘source pole’) to another pole (say ‘destination pole’) with the help of the third pole (say auxiliary pole).
The puzzle has the following two rules:      1. You can’t place a larger disk onto a smaller disk       2. Only one disk can be moved at a time
We’ve already discussed a recursive solution for the Tower of Hanoi. We have also seen that for n disks, a total of  2n – 1 moves are required. 
Iterative Algorithm: 
1. Calculate the total number of moves required i.e. "pow(2, n)
   - 1" here n is number of disks.
2. If number of disks (i.e. n) is even then interchange destination 
   pole and auxiliary pole.
3. for i = 1 to total number of moves:
     if i%3 == 1:
    legal movement of top disk between source pole and 
        destination pole
     if i%3 == 2:
    legal movement top disk between source pole and 
        auxiliary pole    
     if i%3 == 0:
        legal movement top disk between auxiliary pole 
        and destination pole 
Example: 
Let us understand with a simple example with 3 disks:
So, total number of moves required = 7
        S                      A                   D

When i= 1, (i % 3 == 1) legal movement between‘S’ and ‘D’ 
When i = 2,  (i % 3 == 2) legal movement between ‘S’ and ‘A’ 
When i = 3, (i % 3 == 0) legal movement between ‘A’ and ‘D’ ’
When i = 4, (i % 3 == 1) legal movement between ‘S’ and ‘D’ 
When i = 5, (i % 3 == 2) legal movement between ‘S’ and ‘A’
When i = 6, (i % 3 == 0) legal movement between ‘A’ and ‘D’ 
When i = 7, (i % 3 == 1) legal movement between ‘S’ and ‘D’ 
So, after all these destination poles contains all the in order of size. After observing above iterations, we can think that after a disk other than the smallest disk is moved, the next disk to be moved must be the smallest disk because it is the top disk resting on the spare pole and there are no other choices to move a disk.
C++
C
Java
Python3
C#
Javascript
// C++ Program for Iterative Tower of Hanoi#include <iostream>#include <bits/stdc++.h>using namespace std; // A structure to represent a stackstruct Stack{unsigned capacity;int top;int *array;}; // function to create a stack of given capacity.struct Stack* createStack(unsigned capacity){    struct Stack* stack =        (struct Stack*) malloc(sizeof(struct Stack));    stack -> capacity = capacity;    stack -> top = -1;    stack -> array =        (int*) malloc(stack -> capacity * sizeof(int));    return stack;} // Stack is full when top is equal to the last indexint isFull(struct Stack* stack){return (stack->top == stack->capacity - 1);} // Stack is empty when top is equal to -1int isEmpty(struct Stack* stack){return (stack->top == -1);} // Function to add an item to stack. It increases// top by 1void push(struct Stack *stack, int item){    if (isFull(stack))        return;    stack -> array[++stack -> top] = item;} // Function to remove an item from stack. It// decreases top by 1int pop(struct Stack* stack){    if (isEmpty(stack))        return INT_MIN;    return stack -> array[stack -> top--];} //Function to show the movement of disksvoid moveDisk(char fromPeg, char toPeg, int disk){    cout <<"Move the disk " << disk <<" from " << fromPeg << " to "<< toPeg << endl;} // Function to implement legal movement between// two polesvoid moveDisksBetweenTwoPoles(struct Stack *src,            struct Stack *dest, char s, char d){    int pole1TopDisk = pop(src);    int pole2TopDisk = pop(dest);     // When pole 1 is empty    if (pole1TopDisk == INT_MIN)    {        push(src, pole2TopDisk);        moveDisk(d, s, pole2TopDisk);    }     // When pole2 pole is empty    else if (pole2TopDisk == INT_MIN)    {        push(dest, pole1TopDisk);        moveDisk(s, d, pole1TopDisk);    }     // When top disk of pole1 > top disk of pole2    else if (pole1TopDisk > pole2TopDisk)    {        push(src, pole1TopDisk);        push(src, pole2TopDisk);        moveDisk(d, s, pole2TopDisk);    }     // When top disk of pole1 < top disk of pole2    else    {        push(dest, pole2TopDisk);        push(dest, pole1TopDisk);        moveDisk(s, d, pole1TopDisk);    }} //Function to implement TOH puzzlevoid tohIterative(int num_of_disks, struct Stack            *src, struct Stack *aux,            struct Stack *dest){    int i, total_num_of_moves;    char s = 'S', d = 'D', a = 'A';     //If number of disks is even, then interchange    //destination pole and auxiliary pole    if (num_of_disks % 2 == 0)    {        char temp = d;        d = a;        a = temp;    }    total_num_of_moves = pow(2, num_of_disks) - 1;     //Larger disks will be pushed first    for (i = num_of_disks; i >= 1; i--)        push(src, i);     for (i = 1; i <= total_num_of_moves; i++)    {        if (i % 3 == 1)        moveDisksBetweenTwoPoles(src, dest, s, d);         else if (i % 3 == 2)        moveDisksBetweenTwoPoles(src, aux, s, a);         else if (i % 3 == 0)        moveDisksBetweenTwoPoles(aux, dest, a, d);    }} // Driver Programint main(){       // Input: number of disks    unsigned num_of_disks = 3;     struct Stack *src, *dest, *aux;     // Create three stacks of size 'num_of_disks'    // to hold the disks    src = createStack(num_of_disks);    aux = createStack(num_of_disks);    dest = createStack(num_of_disks);     tohIterative(num_of_disks, src, aux, dest);    return 0;} // This code is contributed by shivanisinghss2110
// C Program for Iterative Tower of Hanoi#include <stdio.h>#include <math.h>#include <stdlib.h>#include <limits.h> // A structure to represent a stackstruct Stack{unsigned capacity;int top;int *array;}; // function to create a stack of given capacity.struct Stack* createStack(unsigned capacity){    struct Stack* stack =        (struct Stack*) malloc(sizeof(struct Stack));    stack -> capacity = capacity;    stack -> top = -1;    stack -> array =        (int*) malloc(stack -> capacity * sizeof(int));    return stack;} // Stack is full when top is equal to the last indexint isFull(struct Stack* stack){return (stack->top == stack->capacity - 1);} // Stack is empty when top is equal to -1int isEmpty(struct Stack* stack){return (stack->top == -1);} // Function to add an item to stack. It increases// top by 1void push(struct Stack *stack, int item){    if (isFull(stack))        return;    stack -> array[++stack -> top] = item;} // Function to remove an item from stack. It// decreases top by 1int pop(struct Stack* stack){    if (isEmpty(stack))        return INT_MIN;    return stack -> array[stack -> top--];} //Function to show the movement of disksvoid moveDisk(char fromPeg, char toPeg, int disk){    printf("Move the disk %d from \'%c\' to \'%c\'\n",        disk, fromPeg, toPeg);} // Function to implement legal movement between// two polesvoid moveDisksBetweenTwoPoles(struct Stack *src,            struct Stack *dest, char s, char d){    int pole1TopDisk = pop(src);    int pole2TopDisk = pop(dest);     // When pole 1 is empty    if (pole1TopDisk == INT_MIN)    {        push(src, pole2TopDisk);        moveDisk(d, s, pole2TopDisk);    }     // When pole2 pole is empty    else if (pole2TopDisk == INT_MIN)    {        push(dest, pole1TopDisk);        moveDisk(s, d, pole1TopDisk);    }     // When top disk of pole1 > top disk of pole2    else if (pole1TopDisk > pole2TopDisk)    {        push(src, pole1TopDisk);        push(src, pole2TopDisk);        moveDisk(d, s, pole2TopDisk);    }     // When top disk of pole1 < top disk of pole2    else    {        push(dest, pole2TopDisk);        push(dest, pole1TopDisk);        moveDisk(s, d, pole1TopDisk);    }} //Function to implement TOH puzzlevoid tohIterative(int num_of_disks, struct Stack            *src, struct Stack *aux,            struct Stack *dest){    int i, total_num_of_moves;    char s = 'S', d = 'D', a = 'A';     //If number of disks is even, then interchange    //destination pole and auxiliary pole    if (num_of_disks % 2 == 0)    {        char temp = d;        d = a;        a = temp;    }    total_num_of_moves = pow(2, num_of_disks) - 1;     //Larger disks will be pushed first    for (i = num_of_disks; i >= 1; i--)        push(src, i);     for (i = 1; i <= total_num_of_moves; i++)    {        if (i % 3 == 1)        moveDisksBetweenTwoPoles(src, dest, s, d);         else if (i % 3 == 2)        moveDisksBetweenTwoPoles(src, aux, s, a);         else if (i % 3 == 0)        moveDisksBetweenTwoPoles(aux, dest, a, d);    }} // Driver Programint main(){    // Input: number of disks    unsigned num_of_disks = 3;     struct Stack *src, *dest, *aux;     // Create three stacks of size 'num_of_disks'    // to hold the disks    src = createStack(num_of_disks);    aux = createStack(num_of_disks);    dest = createStack(num_of_disks);     tohIterative(num_of_disks, src, aux, dest);    return 0;}
// Java program for iterative// Tower of Hanoiclass TOH{     // A structure to represent a stackclass Stack{    int capacity;    int top;    int array[];} // Function to create a stack of given capacity.Stack createStack(int capacity){    Stack stack = new Stack();    stack.capacity = capacity;    stack.top = -1;    stack.array = new int[capacity];    return stack;} // Stack is full when the top is equal// to the last indexboolean isFull(Stack stack){    return (stack.top == stack.capacity - 1);} // Stack is empty when top is equal to -1boolean isEmpty(Stack stack){    return (stack.top == -1);} // Function to add an item to stack.It// increases top by 1void push(Stack stack, int item){    if (isFull(stack))        return;             stack.array[++stack.top] = item;} // Function to remove an item from stack.It// decreases top by 1int pop(Stack stack){    if (isEmpty(stack))        return Integer.MIN_VALUE;             return stack.array[stack.top--];} // Function to implement legal movement between// two polesvoid moveDisksBetweenTwoPoles(Stack src, Stack dest,                              char s, char d){    int pole1TopDisk = pop(src);    int pole2TopDisk = pop(dest);     // When pole 1 is empty    if (pole1TopDisk == Integer.MIN_VALUE)    {        push(src, pole2TopDisk);        moveDisk(d, s, pole2TopDisk);    }         // When pole2 pole is empty    else if (pole2TopDisk == Integer.MIN_VALUE)    {        push(dest, pole1TopDisk);        moveDisk(s, d, pole1TopDisk);    }         // When top disk of pole1 > top disk of pole2    else if (pole1TopDisk > pole2TopDisk)    {        push(src, pole1TopDisk);        push(src, pole2TopDisk);        moveDisk(d, s, pole2TopDisk);    }    // When top disk of pole1 < top disk of pole2    else    {        push(dest, pole2TopDisk);        push(dest, pole1TopDisk);        moveDisk(s, d, pole1TopDisk);    }} // Function to show the movement of disksvoid moveDisk(char fromPeg, char toPeg, int disk){    System.out.println("Move the disk " + disk +                            " from " + fromPeg +                              " to " + toPeg);} // Function to implement TOH puzzlevoid tohIterative(int num_of_disks, Stack                  src, Stack aux, Stack dest){    int i, total_num_of_moves;    char s = 'S', d = 'D', a = 'A';      // If number of disks is even, then    // interchange destination pole and    // auxiliary pole    if (num_of_disks % 2 == 0)    {        char temp = d;        d = a;        a  = temp;    }    total_num_of_moves = (int)(Math.pow(                         2, num_of_disks) - 1);      // Larger disks will be pushed first    for(i = num_of_disks; i >= 1; i--)        push(src, i);      for(i = 1; i <= total_num_of_moves; i++)    {        if (i % 3 == 1)          moveDisksBetweenTwoPoles(src, dest, s, d);          else if (i % 3 == 2)          moveDisksBetweenTwoPoles(src, aux, s, a);          else if (i % 3 == 0)          moveDisksBetweenTwoPoles(aux, dest, a, d);    }} // Driver codepublic static void main(String[] args){         // Input: number of disks    int num_of_disks = 3;         TOH ob = new TOH();    Stack src, dest, aux;         // Create three stacks of size 'num_of_disks'    // to hold the disks    src = ob.createStack(num_of_disks);    dest = ob.createStack(num_of_disks);    aux = ob.createStack(num_of_disks);         ob.tohIterative(num_of_disks, src, aux, dest);}} // This code is contributed by Sumit Ghosh
# Python3 program for iterative Tower of Hanoiimport sys # A structure to represent a stackclass Stack:    # Constructor to set the data of    # the newly created tree node    def __init__(self, capacity):        self.capacity = capacity        self.top = -1        self.array = [0]*capacity # function to create a stack of given capacity.def createStack(capacity):    stack = Stack(capacity)    return stack  # Stack is full when top is equal to the last indexdef isFull(stack):    return (stack.top == (stack.capacity - 1))   # Stack is empty when top is equal to -1def isEmpty(stack):    return (stack.top == -1)   # Function to add an item to stack.# It increases top by 1def push(stack, item):    if(isFull(stack)):        return    stack.top+=1    stack.array[stack.top] = item   # Function to remove an item from stack.# It decreases top by 1def Pop(stack):    if(isEmpty(stack)):        return -sys.maxsize    Top = stack.top    stack.top-=1    return stack.array[Top]   # Function to implement legal# movement between two polesdef moveDisksBetweenTwoPoles(src, dest, s, d):    pole1TopDisk = Pop(src)    pole2TopDisk = Pop(dest)     # When pole 1 is empty    if (pole1TopDisk == -sys.maxsize):        push(src, pole2TopDisk)        moveDisk(d, s, pole2TopDisk)           # When pole2 pole is empty    else if (pole2TopDisk == -sys.maxsize):        push(dest, pole1TopDisk)        moveDisk(s, d, pole1TopDisk)           # When top disk of pole1 > top disk of pole2    else if (pole1TopDisk > pole2TopDisk):        push(src, pole1TopDisk)        push(src, pole2TopDisk)        moveDisk(d, s, pole2TopDisk)           # When top disk of pole1 < top disk of pole2    else:        push(dest, pole2TopDisk)        push(dest, pole1TopDisk)        moveDisk(s, d, pole1TopDisk)   # Function to show the movement of disksdef moveDisk(fromPeg, toPeg, disk):    print("Move the disk", disk, "from '", fromPeg, "' to '", toPeg, "'")   # Function to implement TOH puzzledef tohIterative(num_of_disks, src, aux, dest):    s, d, a = 'S', 'D', 'A'       # If number of disks is even, then interchange    # destination pole and auxiliary pole    if (num_of_disks % 2 == 0):        temp = d        d = a        a = temp    total_num_of_moves = int(pow(2, num_of_disks) - 1)       # Larger disks will be pushed first    for i in range(num_of_disks, 0, -1):        push(src, i)       for i in range(1, total_num_of_moves + 1):        if (i % 3 == 1):            moveDisksBetweenTwoPoles(src, dest, s, d)           else if (i % 3 == 2):            moveDisksBetweenTwoPoles(src, aux, s, a)           else if (i % 3 == 0):            moveDisksBetweenTwoPoles(aux, dest, a, d) # Input: number of disksnum_of_disks = 3 # Create three stacks of size 'num_of_disks'# to hold the diskssrc = createStack(num_of_disks)dest = createStack(num_of_disks)aux = createStack(num_of_disks) tohIterative(num_of_disks, src, aux, dest) # This code is contributed by divyeshrabadiya07.
// C# program for iterative// Tower of Hanoiusing System; class GFG{    // A structure to represent a stack    public class Stack    {        public int capacity;        public int top;        public int []array;    }         // function to create a stack of given capacity.    Stack createStack(int capacity)    {        Stack stack = new Stack();        stack.capacity = capacity;        stack.top = -1;        stack.array = new int[capacity];        return stack;    }         // Stack is full when top is equal to the last index    Boolean isFull(Stack stack)    {        return (stack.top == stack.capacity - 1);    }         // Stack is empty when top is equal to -1    Boolean isEmpty(Stack stack)    {        return (stack.top == -1);    }         // Function to add an item to stack.    // It increases top by 1    void push(Stack stack,int item)    {        if(isFull(stack))            return;        stack.array[++stack.top] = item;    }         // Function to remove an item from stack.     // It decreases top by 1    int pop(Stack stack)    {        if(isEmpty(stack))            return int.MinValue;        return stack.array[stack.top--];    }         // Function to implement legal     // movement between two poles    void moveDisksBetweenTwoPoles(Stack src, Stack dest,                                            char s, char d)    {        int pole1TopDisk = pop(src);        int pole2TopDisk = pop(dest);         // When pole 1 is empty        if (pole1TopDisk == int.MinValue)        {            push(src, pole2TopDisk);            moveDisk(d, s, pole2TopDisk);        }                 // When pole2 pole is empty        else if (pole2TopDisk == int.MinValue)        {            push(dest, pole1TopDisk);            moveDisk(s, d, pole1TopDisk);        }                 // When top disk of pole1 > top disk of pole2        else if (pole1TopDisk > pole2TopDisk)        {            push(src, pole1TopDisk);            push(src, pole2TopDisk);            moveDisk(d, s, pole2TopDisk);        }                 // When top disk of pole1 < top disk of pole2        else        {            push(dest, pole2TopDisk);            push(dest, pole1TopDisk);            moveDisk(s, d, pole1TopDisk);        }    }         // Function to show the movement of disks    void moveDisk(char fromPeg, char toPeg, int disk)    {        Console.WriteLine("Move the disk "+disk +                        " from "+fromPeg+" to "+toPeg);    }         // Function to implement TOH puzzle    void tohIterative(int num_of_disks, Stack                src, Stack aux, Stack dest)    {        int i, total_num_of_moves;        char s = 'S', d = 'D', a = 'A';             // If number of disks is even, then interchange        // destination pole and auxiliary pole        if (num_of_disks % 2 == 0)        {            char temp = d;            d = a;            a = temp;        }        total_num_of_moves = (int) (Math.Pow(2, num_of_disks) - 1);             // Larger disks will be pushed first        for (i = num_of_disks; i >= 1; i--)            push(src, i);             for (i = 1; i <= total_num_of_moves; i++)        {            if (i % 3 == 1)            moveDisksBetweenTwoPoles(src, dest, s, d);                 else if (i % 3 == 2)            moveDisksBetweenTwoPoles(src, aux, s, a);                 else if (i % 3 == 0)            moveDisksBetweenTwoPoles(aux, dest, a, d);        }    }         // Driver code    public static void Main(String []args)    {                 // Input: number of disks        int num_of_disks = 3;                 GFG ob = new GFG();        Stack src, dest, aux;                 // Create three stacks of size 'num_of_disks'        // to hold the disks        src = ob.createStack(num_of_disks);        dest = ob.createStack(num_of_disks);        aux = ob.createStack(num_of_disks);                 ob.tohIterative(num_of_disks, src, aux, dest);    }} // This code is Contributed by Arnab Kundu
<script>    // Javascript program for iterative Tower of Hanoi         // A structure to represent a stack    class Stack    {        constructor(capacity) {            this.capacity = capacity;            this.top = -1;            this.array = new Array(capacity);        }    }         // function to create a stack of given capacity.    function createStack(capacity)    {        let stack = new Stack(capacity);        return stack;    }         // Stack is full when top is equal to the last index    function isFull(stack)    {        return (stack.top == (stack.capacity - 1));    }          // Stack is empty when top is equal to -1    function isEmpty(stack)    {        return (stack.top == -1);    }          // Function to add an item to stack.    // It increases top by 1    function push(stack, item)    {        if(isFull(stack))            return;        stack.array[++stack.top] = item;    }          // Function to remove an item from stack.    // It decreases top by 1    function pop(stack)    {        if(isEmpty(stack))            return Number.MIN_VALUE;        return stack.array[stack.top--];    }          // Function to implement legal    // movement between two poles    function moveDisksBetweenTwoPoles(src, dest, s, d)    {        let pole1TopDisk = pop(src);        let pole2TopDisk = pop(dest);          // When pole 1 is empty        if (pole1TopDisk == Number.MIN_VALUE)        {            push(src, pole2TopDisk);            moveDisk(d, s, pole2TopDisk);        }                  // When pole2 pole is empty        else if (pole2TopDisk == Number.MIN_VALUE)        {            push(dest, pole1TopDisk);            moveDisk(s, d, pole1TopDisk);        }                  // When top disk of pole1 > top disk of pole2        else if (pole1TopDisk > pole2TopDisk)        {            push(src, pole1TopDisk);            push(src, pole2TopDisk);            moveDisk(d, s, pole2TopDisk);        }                  // When top disk of pole1 < top disk of pole2        else        {            push(dest, pole2TopDisk);            push(dest, pole1TopDisk);            moveDisk(s, d, pole1TopDisk);        }    }          // Function to show the movement of disks    function moveDisk(fromPeg, toPeg, disk)    {        document.write("Move the disk "+disk +                        " from '"+fromPeg+"' to '"+toPeg + "'</br>");    }          // Function to implement TOH puzzle    function tohIterative(num_of_disks, src, aux, dest)    {        let i, total_num_of_moves;        let s = 'S', d = 'D', a = 'A';              // If number of disks is even, then interchange        // destination pole and auxiliary pole        if (num_of_disks % 2 == 0)        {            let temp = d;            d = a;            a = temp;        }        total_num_of_moves = parseInt(Math.pow(2, num_of_disks) - 1, 10);              // Larger disks will be pushed first        for (i = num_of_disks; i >= 1; i--)            push(src, i);              for (i = 1; i <= total_num_of_moves; i++)        {            if (i % 3 == 1)                moveDisksBetweenTwoPoles(src, dest, s, d);                  else if (i % 3 == 2)                moveDisksBetweenTwoPoles(src, aux, s, a);                  else if (i % 3 == 0)                moveDisksBetweenTwoPoles(aux, dest, a, d);        }    }         // Input: number of disks    let num_of_disks = 3;     let src, dest, aux;     // Create three stacks of size 'num_of_disks'    // to hold the disks    src = createStack(num_of_disks);    dest = createStack(num_of_disks);    aux = createStack(num_of_disks);     tohIterative(num_of_disks, src, aux, dest);         // This code is contributed by decode2207</script>
Output: 
Move the disk 1 from 'S' to 'D'
Move the disk 2 from 'S' to 'A'
Move the disk 1 from 'D' to 'A'
Move the disk 3 from 'S' to 'D'
Move the disk 1 from 'A' to 'S'
Move the disk 2 from 'A' to 'D'
Move the disk 1 from 'S' to 'D'
Related Articles 
Recursive Functions
Tail recursion
Quiz on Recursion
References: http://en.wikipedia.org/wiki/Tower_of_Hanoi#Iterative_solution
This article is contributed by Anand Barnwal. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
VIKASGUPTA1127
andrew1234
singhpriansh
jitendra jaria
ashish1994
kk773572498
decode2207
divyeshrabadiya07
shivanisinghss2110
surinderdawra388
Divide and Conquer
Stack
Divide and Conquer
Stack
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Divide and Conquer Algorithm | Introduction
Median of two sorted arrays of different sizes
Write a program to calculate pow(x,n)
Count number of occurrences (or frequency) in a sorted array
Divide and Conquer | Set 5 (Strassen's Matrix Multiplication)
Stack Data Structure (Introduction and Program)
Stack Class in Java
Stack in Python
Inorder Tree Traversal without Recursion
Check for Balanced Brackets in an expression (well-formedness) using Stack