两个堆栈同时存在时，它的执行过程是如何进行的

Question

就拿常规的汉诺塔问题来讲吧：
private void Ha(int n, int x, int y, int z) {
if (n > 0) {
System.out.println("x0的位置： " + x +" y0的位置: " + y+ "   ,z0的位置    "+z);
//运用递归，将第一个塔上的n-1个盘子移动到第三个塔
Ha(n - 1, x, z, y);
// System.out.println("move top disk form  " +x+"  to  "+y);
System.out.println("x1的位置： " + x +" y1的位置: " + y+ "   ,z1的位置    "+z);
//将第一个塔与第三个互换
Ha(n - 1, z, y, x);
System.out.println("x2的位置： " + x +" y2的位置: " + y+ "   ,z2的位置    "+z);
}
}
调用结果是：
请输入数:3
x0的位置： 1 y0的位置: 2   ,z0的位置    3
x0的位置： 1 y0的位置: 3   ,z0的位置    2
x0的位置： 1 y0的位置: 2   ,z0的位置    3
x1的位置： 1 y1的位置: 2   ,z1的位置    3
x2的位置： 1 y2的位置: 2   ,z2的位置    3
x1的位置： 1 y1的位置: 3   ,z1的位置    2
x0的位置： 2 y0的位置: 3   ,z0的位置    1
x1的位置： 2 y1的位置: 3   ,z1的位置    1
x2的位置： 2 y2的位置: 3   ,z2的位置    1
x2的位置： 1 y2的位置: 3   ,z2的位置    2
x1的位置： 1 y1的位置: 2   ,z1的位置    3
x0的位置： 3 y0的位置: 2   ,z0的位置    1
x0的位置： 3 y0的位置: 1   ,z0的位置    2
x1的位置： 3 y1的位置: 1   ,z1的位置    2
x2的位置： 3 y2的位置: 1   ,z2的位置    2
x1的位置： 3 y1的位置: 2   ,z1的位置    1
x0的位置： 1 y0的位置: 2   ,z0的位置    3
x1的位置： 1 y1的位置: 2   ,z1的位置    3
x2的位置： 1 y2的位置: 2   ,z2的位置    3
x2的位置： 3 y2的位置: 2   ,z2的位置    1
x2的位置： 1 y2的位置: 2   ,z2的位置    3大家能帮我分析下吗？每步是如何执行的吗？？？

Answer 1

简单的说，n层汉诺塔问题可以拆分为 
n 从A到B ：
第一步 n-1 从A 到C   
第二步 第 n 从A到B  
第三步 n-1 从C到B
其中第一第三步都可以递归。

Answer 2

递归 在编译器里是用堆栈实现的遇到Ha（）压栈，Ha（）中继续调用Ha（）是一个继续压栈的过程在你的函数里，当n<=0时Ha（）出栈private void Ha(int n, int x, int y, int z) { 
if (n > 0) { 
System.out.println("x0的位置： " + x +" y0的位置: " + y+ "  ,z0的位置    "+z); //1
//运用递归，将第一个塔上的n-1个盘子移动到第三个塔 
Ha(n - 1, x, z, y);                                                         //2
// System.out.println("move top disk form  " +x+"  to  "+y); 
System.out.println("x1的位置： " + x +" y1的位置: " + y+ "  ,z1的位置    "+z); //3
//将第一个塔与第三个互换 
Ha(n - 1, z, y, x);                                                         //4
System.out.println("x2的位置： " + x +" y2的位置: " + y+ "  ,z2的位置    "+z); //5
} 
} x0的位置： 1 y0的位置: 2  ,z0的位置    3 //1
x0的位置： 1 y0的位置: 3  ,z0的位置    2 //2
x0的位置： 1 y0的位置: 2  ,z0的位置    3 //3
x1的位置： 1 y1的位置: 2  ,z1的位置    3 //4
x2的位置： 1 y2的位置: 2  ,z2的位置    3 //5
x1的位置： 1 y1的位置: 3  ,z1的位置    2 //6
x0的位置： 2 y0的位置: 3  ,z0的位置    1 //7
x1的位置： 2 y1的位置: 3  ,z1的位置    1 //8
x2的位置： 2 y2的位置: 3  ,z2的位置    1 //9
x2的位置： 1 y2的位置: 3  ,z2的位置    2 //10
x1的位置： 1 y1的位置: 2  ,z1的位置    3 //11
x0的位置： 3 y0的位置: 2  ,z0的位置    1 //12
x0的位置： 3 y0的位置: 1  ,z0的位置    2 //13
x1的位置： 3 y1的位置: 1  ,z1的位置    2 //14
x2的位置： 3 y2的位置: 1  ,z2的位置    2 //15
x1的位置： 3 y1的位置: 2  ,z1的位置    1 //16
x0的位置： 1 y0的位置: 2  ,z0的位置    3 //17
x1的位置： 1 y1的位置: 2  ,z1的位置    3 //18
x2的位置： 1 y2的位置: 2  ,z2的位置    3 //19
x2的位置： 3 y2的位置: 2  ,z2的位置    1 //20
x2的位置： 1 y2的位置: 2  ,z2的位置    3 //21
姑且把递归堪称一个往里层钻的过程，外层函数被调用后
System.out.println("x0的位置： " + x +" y0的位置: " + y+ "  ,z0的位置    "+z); //1
输出  x0的位置： 1 y0的位置: 2  ,z0的位置    3 //1
然后遇到  Ha(n - 1, x, z, y);               //2System.out.println("x0的位置： " + x +" y0的位置: " + y+ "  ,z0的位置    "+z); //1
输出x0的位置： 1 y0的位置: 3  ,z0的位置    2 //2
因为有if (n > 0)，而每次调用Ha(n - 1, x, z, y); 都会-1
因此有了3次System.out.println("x0的位置： " + x +" y0的位置: " + y+ "  ,z0的位置    "+z); //1
和System.out.println("x1的位置： " + x +" y1的位置: " + y+ "  ,z1的位置    "+z); //3
哎实在说不下去了，我表达能力不行，而且这个表达在字面上实在是长篇大论你只要抓住一点
Ha(n - 1, x, z, y);                                                         //2
Ha(n - 1, z, y, x);                                                         //4
没什么必然练习，各干各的，自己在草稿纸上画一下

Answer 3

之所以有21行输出，外层输出了3行很显然然后其余18行则是6*3的结果，3自然是每个函数体就有3个println，而6则代表了（3，2，1，1，2，3）这个过程，（3，2，1）是因为每次Ha对n-1

Answer 4

Ha(n - 1, x, z, y);
当作到这句的时候，函数信息进栈，调用Ha(n - 1, x, z, y)的具体过程，
以此类推，直到解决完才会作下面
Ha(n - 1, z, y, x);