请问一下，怎么用递归办法理解汉诺塔问题

count = 0
def hanoi(n, src, dst, mid):
      global count
      if n==1:
         print("{}:{}->{}".format(1,src,dst))
         count +=1
      else:
         hanoi(n-1, src, mid, dst)
         print("{}:{}->{}".format(n,src,dst))
         count +=1
         hanoi(n-1, mid, dst, src)

hanoi(100, "A", "B", "C")
print(count)

想了一天，怎么也琢磨不明白，大家有什么巧妙的思考办法吗？

我是用的java，大致就是先把n-1个disks从src移到mid，然后把第n个disk从src移到dst，再把那n-1个disks从第mid移到dst，希望对你有用

    public void hanoi(int n, int src, int dst, int mid) {
        if (n == 0) return;
        hanoi(n - 1, src, mid, dst);
        System.out.println("Move disk " + n + " from peg " + src + " to peg " + dst);
        hanoi(n - 1, mid, dst, src);
    }

原理和楼上说的一样
int h(int n) {
if(n == 1)
    return 1;
else
    return 2 * h(n-1 ) + 1;
}

h ( n-1) : source -> mid
1:   source -> dest
h(n-1) : mid -> dest

其实主要的逻辑很简单，就是divide and conquer. 要解决输入规模为n的问题，我们就先要解决n -  1的问题，然后最后不断往下压触底，然后解决了n = 1的问题，我们就能解决n = 2 的问题，然后就是n = 3的问题，以此类推最后解决n = n的问题。汉诺塔问题的关键是有三个塔，一个是source，一个是buffer，一个是destination。在进行不同层之间的递归的时候，buffer和destination和buffer是要互相转换的。
public void main(String[] args) {
        int n = 3;       
        Tower[] towers = new Tower[n];
        for(int i = 0; i < 3; i ++) {
                towers[i] = new Tower(i);
        }

        for(int i = n - 1; i >= 0; i --) {
                towers[0].add(i);
        }
       
        towers[0].moveDisks(n, towers[2], towers[1]);
}

public class Tower {
        private Stack<Integer> disks;
        private int index;
        public Tower(int i) {
                disks = new Stack<Integer>();
                index = i;
        }
               
        public int index() {
                return index;
        }
       
        public void add(int d) {
                if(!disks.isEmpty() && disks.peek() <= d) {
                        System.out.println("Error placing disk" + d);
                } else {
                        disk.push(d);
                }
        }

        public void moveTopTo(Tower t) {
                int top = disk.pop();
                t.add(top);
        }

        public void moveDisk(int n, Tower destination, Tower buffer) {
                if(n > 0) {
                        moveDisks(n - 1, buffer, destination);
                        moveTopTo(destination);
                        buffer.moveDists(n - 1, destination, this);
                }
        }
}

汉诺塔问题是不是只有用递归方法才能解决，用正向的迭代方法或者别的方法有可能解决吗？