Tower of Hanoi logic

Question

Okay so I have an assignment on the tower of Hanoi problem. I got the code and got it working but I just don't know what's going on behind it. Can someone please explain? I don't understand the lines where it says solveTower(num-1, from, other, to) and solveTower(1, from, to, other) and solveTower(num-1, other, to, from). I understand what it is doing, it's just moving the number of disks from one peg to another using the other one. I just don't understand what's going on behind it. Like why do I have to move the num-1 disks from the left peg to the middle, the move the biggest disk from the left peg to right peg, and move the num-1 disks from the middle to the right? Why can't I just say something like solveTower(num, from, to, other) to move all the disks from the left peg to the right peg? Here's my driver:

public class Hanoi_Driver
{
  public static void main(String[] args) 
  {
    Tower tower = new Tower();
    tower.solveTower();
  }
}

And here's my object:

import java.util.Scanner;

public class Tower 
{

  private int size;
  private String fromPeg = "A";
  private String toPeg = "C";
  private String otherPeg = "B";

  public Tower() 
  {
    this.size = size;
    this.fromPeg = fromPeg;
    this.toPeg = toPeg;
    this.otherPeg = otherPeg;
  }

  public void solveTower()
  {
    Scanner keyboard = new Scanner(System.in);
    System.out.println("What do you want the size to be?");
    size = keyboard.nextInt();
    System.out.println("Steps for solving " + size + " disk tower of hanoi puzzle, ");

    solveTower(size, fromPeg, toPeg, otherPeg);
  }

  private void solveTower(int num, String from, String to, String other) {

    if (num == 1) {
      System.out.println("Move disk from " + from +
                         " to " + to + ".");
    }
    else {
      solveTower(num-1, from, other, to);
      solveTower(1, from, to, other);
      solveTower(num-1, other, to, from);
    }
  }
}

Answer 1

These lines

  solveTower(num-1, from, other, to);
  solveTower(1, from, to, other);
  solveTower(num-1, other, to, from);

indicate that if the solution is not already found (the else of num == 1, in other words where num > 1 or actually when num < 1), then #1: move all but one (num-1) from from to other (not onto to), #2: move the remaining one onto the correct destination to, and #3: move back the original ones from other back to to.
Each time, the third argument is the extra peg to be used.
When you start here:

solveTower(size, fromPeg, toPeg, otherPeg);

you are saying "solve the entire problem".
The other recursive calls to solveTower` break the problem into smaller pieces.
This works just fine for me:

What do you want the size to be?
3
Steps for solving 3 disk tower of hanoi puzzle, 
Move disk from A to C.
Move disk from A to B.
Move disk from C to B.
Move disk from A to C.
Move disk from B to A.
Move disk from B to C.
Move disk from A to C.

With size larger than 3, then the steps to solve the problem become more complex. Sizes 1 and 2 work fine, but size 0 is not handled correctly. (There is no check in the solver for sizes of 0 or less.)
You can delete some unnecessary code in the Tower constructor; it only needs to be:

public Tower() { }

and you might close the Scanner keyboard:

  public void solveTower()
  {
  ... (code removed to reduce length of post)
    solveTower(size, fromPeg, toPeg, otherPeg);
    keyboard.close();
  }