这是一个分盘子的题目
#include <stdio.h>
void hanoi(int n,char one,char twe,char three);
void nove(char x,char y);
void main()
{
    hanoi(3,'a','b','c');
}
void hanoi(int n,char one,char two,char three)
{
    if(n==1)
        nove(one,three);
    else
    {
       hanoi(n-1,one,three,two);
       nove(one,three);
       hanoi(n-1,two,one,three);
    }
}
void nove(char x,char y)
{
    printf("%c-->%c\n",x,y);
}
红色的那一段代码，具体是怎么执行的，求真相？

不断入栈与不断退栈，结束递归条件是if(n==1)

就这么简单？？

不简单，可以写出来，不过麻烦。

可以看严蔚敏和吴伟民的数据结构，里面有这个例程使用栈时具体的对栈的操作情况，讲的超级详细

这个写出来稍微有点麻烦，楼主可以看看函数递归调用方面的知识。递归调用，不断开辟重名存储单元，直到递归调用结束再逐一释放

写一小段伪代码
h(3,a,b,c)
{
   h(2,a,c,b);
   n
   h(2);
}

h(2,a,c,b)
{
   h(1,a,b,c);
   n
   h(1);
}

h(1,a,b,c)
{
   printf   a->c
}

h(2,a,c,b)
{
    prinf   a->b
    h(1,c,a,b)
}

h(1,c,a,b)
{
    printf  c->b   
}
...
不知道楼主明白不

完整分析，细节上不明白可以继续问，本人菜鸟，有不对地方，望高手指教.
hanoi(3,a,b,c)      //生成最先入栈的函数
{

   if(0)            //约束条件还没有触发，所以执下面语句
 
   hanoi(2,a,c,b);  //这个准备入栈
   nove(a,c);       //等上面函数执行完，才执行这个
   hanoi(2,b,a,c);  //等上面函数执行完，才执行这个
}

hanoi(2,a,c,b)      //第二个入栈函数
{
   if(0)            //约束条件还没有触发，所以执下面语句
   hanoi(1,a,b,c);  //这个准备入栈
   nove(a,b);       //等上面函数执行完，才执行这个
   hanoi(1,c,a,b);  //等上面函数执行完，才执行这个
}

hanoi(1,a,b,c)       //执完这个函数，退栈hanoi(2,a,c,b)
{
   if(1)             //约束条件触发，所以打印出语句
   printf   a->c
}

hanoi(2,a,c,b)          //指向这个函数
{
   if(0)            //约束条件还没有触发，所以执下面语句
   hanoi(1,a,b,c);  //这个执行完，所以执行下面语句
   nove(a,b);       //打印 printf   a->b
   hanoi(1,c,a,b);  //准备入栈
}

hanoi(1,c,a,b)     //执完这个函数，退栈hanoi(3,a,b,c)  
{
  if(1)            //约束条件触发，所以打印出语句
    printf  c->b   
}

hanoi(3,a,b,c)      //执行这个函数
{

   if(0)            //约束条件还没有触发，所以执下面语句
 
   hanoi(2,a,c,b);  //执行完这个函数，开始执行下面函数
   nove(a,c);       //打印 printf   a->c
   hanoi(2,b,a,c);  //准备入栈
}

   hanoi(2,b,a,c)   //再一次，再行这个函数
{
    if(0)           //约束条件还没有触发，所以执下面语句
   hanoi(1,b,c,a);  //这个准备入栈
   nove(b,c);       //等上面函数执行完，才执行这个
   hanoi(1,a,b,c);  //等上面函数执行完，才执行这个
}

hanoi(1,b,c,a)     //执完这个函数，退栈hanoi(2,b,a,c)
{
  if(1)            //约束条件触发，所以打印出语句
    printf  b->a   
}

   hanoi(2,b,a,c)   //执行这个函数
{
    if(0)           //约束条件还没有触发，所以执下面语句
   hanoi(1,b,c,a);  //这个函数己经完成
   nove(b,c);       //执行这个函数，开始打印  b->c
   hanoi(1,a,b,c);  //准备入栈
}

hanoi(1,a,b,c)     //执完这个函数，退栈hanoi(3,a,b,c)
{
  if(1)            //约束条件触发，所以打印出语句
    printf  a->c   
}

hanoi(3,a,b,c)    //最后出栈，划上句号

之前还是有些漏，现在补充，望高手指教一下

hanoi(3,a,b,c)      //执行这个函数
{

   if(0)            //约束条件还没有触发，所以执下面语句
   ...

   hanoi(2,a,c,b);  //准备调用hanoi(2,a,c,b),这个所谓"自己调用自己"迫使hanoi(3,a,b,c)入栈，保留hanoi(3,a,b,c)一些数据
   nove(a,c);       //等上面函数执行完，才执行这个
   hanoi(2,b,a,c);  //等上面函数执行完，才执行这个
}

hanoi(2,a,c,b)      //执行hanoi(2,a,c,b)函数，从头执行到尾
{
   if(0)            //约束条件还没有触发，所以执下面语句
   ...

   hanoi(1,a,b,c);  //准备调用hanoi(1,a,b,c),迫使hanoi(2,a,c,b)入栈，保留hanoi(2,a,c,b)一些数据
   nove(a,b);       //等上面函数执行完，才执行这个
   hanoi(1,c,a,b);  //等上面函数执行完，才执行这个
}

hanoi(1,a,b,c)       //执行完这个函数，退栈hanoi(2,a,c,b),记住从那地方调用，就从那地方回去,执行下一条语句.
{
   if(1)             //约束条件触发，所以打印出语句
   printf   a->c
}

hanoi(2,a,c,b)      //执行这个函数,记住从那地方调用，就从那地方回去.
{
   if(0)            //约束条件还没有触发，所以执下面语句
   ...
   hanoi(1,a,b,c);  //这个执行完，所以执行下面语句
   nove(a,b);       //打印 printf   a->b
   hanoi(1,c,a,b);  //准备调用hanoi(1,c,a,b),迫使hanoi(2,a,c,b)入栈，保留hanoi(2,a,c,b)一些数据
}

hanoi(1,c,a,b)     //执完这个函数，退栈hanoi(2,a,c,b), 记住从那地方调用，就从那地方回去,执行下一条语句.
{
  if(1)            //约束条件触发，所以打印出语句
    printf  c->b   
}

hanoi(2,a,c,b)     //下面没有执行语句，结束这个函数，现在退栈hanoi(3,a,b,c), 记住从那地方调用，就从那地方回去,执行下一条语句.
{}

hanoi(3,a,b,c)      //执行这个函数
{

   if(0)            //约束条件还没有触发，所以执下面语句
   ...
   hanoi(2,a,c,b);  //执行完这个函数，开始执行下面函数
   nove(a,c);       //打印 printf   a->c
   hanoi(2,b,a,c);  //准备调用hanoi(2,b,a,c),迫使hanoi(3,a,b,c)入栈，保留hanoi(3,a,b,c)一些数据
}

   hanoi(2,b,a,c)   //再一次，再行这个函数
{
    if(0)           //约束条件还没有触发，所以执下面语句
    ...
   hanoi(1,b,c,a);  //准备调用hanoi(1,b,c,a),迫使hanoi(2,b,a,c)入栈，保留hanoi(2,b,a,c)一些数据
   nove(b,c);       //等上面函数执行完，才执行这个
   hanoi(1,a,b,c);  //等上面函数执行完，才执行这个
}

hanoi(1,b,c,a)     //执完这个函数，退栈hanoi(2,b,a,c),记住从那地方调用，就从那地方回去,执行下一条语句.
{
  if(1)            //约束条件触发，所以打印出语句
    printf  b->a   
}

   hanoi(2,b,a,c)   //继续执行这个函数
{
    if(0)           //约束条件还没有触发，所以执下面语句
     ...
   hanoi(1,b,c,a);  //这个函数己经完成
   nove(b,c);       //执行这个函数，开始打印  b->c
   hanoi(1,a,b,c);  //准备调用hanoi(1,a,b,c),迫使hanoi(2,b,a,c)入栈，保留hanoi(2,b,a,c)一些数据
}


hanoi(1,a,b,c)     //执完这个函数，退栈hanoi(2,b,a,c),记住从那地方调用，就从那地方回去,顺便执行下一条语句.
{
  if(1)            //约束条件触发，所以打印出语句
    printf  a->c   
}

 hanoi(2,b,a,c)   //下面没有执行语句，结束这个函数，现在退栈hanoi(3,a,b,c), 记住从那地方调用，就从那地方回去,执行下一条语句.
{}

hanoi(3,a,b,c)    //下面没有执行语句，结束这个函数，出栈与入栈在这里划上句号.
{}
p.s 这个最好有汇编基础，不然不好明白

[ 本帖最后由 点线面 于 2011-2-1 16:11 编辑 ]