#include<stdio.h>
void hannuota(int n,char f1,char f2,char f3);
int main()
{
    int n;
    printf("请输入盘子的个数:");
    scanf("%d",&n);
    hannuota(n,'A','B','C');
    return 0;
}
void hannuota(int n,char f1,char f2,char f3)
{
    if (1==n)                                          //他这明明 是将最上层的一个 盘子移过去，为何 却说是,最后只剩下一的个，移过去
    {
        printf("编号%d 从%c移动到%c\n",n,f1,f3);                  
    }
    else
    {
        hannuota(n-1,f1,f3,f2);                     //调用此函数说是为了借助f3从f1移到f2                                                  
                                                    //可是这调用的实参和形参都是颠倒的,也就是说第一次调用是移到了f2但是，第二次由于形参和
                                                    //实参的颠倒  ,表面上看去是已到了f2实际上是移到了f3.
        printf("编号%d 从%c移动到%c\n",n,f1,f3);
        hannuota(n-1,f2,f1,f3);                             
    }
    return;
}
//反正 光从 伪代码 去理解 源代码  不晓得为何 很难理解,,,很糊涂

拿个实例跟踪一下程序就知道了

????????
我晓得 那样做 一定会 出正确结果的
只是 不晓得 如何从 他们所说的那种思维去理解 ..................

hannuota( n,f1, f2, f3)说明将n个盘子以f2为中介，从f1移到f3上，但要达到这个效果就要先把顶上n-1个盘子从f1移到f2上(此时就需要以f3作为中介了)，再把最后一个盘子从f1移到f3上，然后再将f2上的n-1个盘子移到f3上即可（将f2上的盘子移到f3上就要以f1为中介），如此递归即可;就是数学上的逆推的思想；
从上面的分析可以看出来最后会分析到n==1的情况;当n==1的时候就不需要中介了，直接移过去就好了;

首先 先谢谢你.

递归 这些什么的 我都理解 只是不晓得 程序的执行如何围绕了那个神马n-1放B上 n放C上 然后n-1借助A放C上     的思想

例如 要移动3个盘子

先调用 hannuota(3,’A’,’B’,’C’)
因为 n!=1 所以 又调用 hannuota(2,’A’,’C’,’B’)
因为 n!=1 所以 调用 hannuota(1,A’,’B,’C)
此时 因为n==1
所以
输出语句编号1从A移动到C
然后返回 

返回到hannuota(2,’A’,’C’,’B’)
接着执行后面的语句
输出语句编号2从A移动到B
然后 调用hannuota(1,’C’,’A,’B’)
因为n==1
所以
输出语句编号1从C移动到B
然后 返回返回

返回到hannuota(3,’A’,’B’,’C’)
输出语句编号3从A移动到C
然后调用hannuota(2,’B’,’A,’C’)
因为n!=1 所以 调用hannuota(1,’B’,’C,’A’)
因为n==1 所以 输出编号1从B移动到A
然后返回

返回到hannuota(2,’B’,’A,’C’)
输出语句编号2从B移动到C
然后 调用hannuota(1,’A’,’B’,’C’)
因为n==1所以 输出编号1从A移动到C

然后返回返回 结束

求解决 我心中的疑惑

void hannuota(int n,char f1,char f2,char f3)
{
    if (1==n)                                          //移动思想就是将A上的借助C，移动到B，然后在将B上的借助A，移动到C，这样就成功了，    {
        printf("编号%d 从%c移动到%c\n",n,f1,f3);                  
    }
    else
    {
        hannuota(n-1,f1,f3,f2);                     //调用此函数说是为了借助f3从f1移到f2                                                  
                                                    //可是这调用的实参和形参都是颠倒的,也就是说第一次调用是移到了f2但是，第二次由于形参和
                                                    //实参的颠倒  ,表面上看去是已到了f2实际上是移到了f3.
        printf("编号%d 从%c移动到%c\n",n,f1,f3);
        hannuota(n-1,f2,f1,f3);                             
    }
    return;
}
参数没什么关系，只要位置对就行，比如有n个盘子，可以分为n-1和一个，一个最大的在下面，n-1个在上面，看成个整体，你为了移动成功，是不是必须先把最后一个先放到正确的位置，这也就是为什么是最后一个了。然后就递归

这个思想 我晓得.
肯定是要先将 最底层的最大的一个 肯定是要在n-1个之前 放到C上的  这是这个游戏的规则  大的不能再小的上面 .然后再将n-1放 C上 这些 我都晓得
请看第5楼和前几楼  这个程序是按着那个思想写的  但，我怎么也理解不了 那程序的执行流程 是围绕和遵循着 那个思想....  我的疑惑是这个...
 

看看这个能不能帮助理解，每行最后的数字就是移动盘子的次序。
'                                                          (1)-1 Hanoi(1,’a’,’b’,’c’)=move(‘a’,’c’)---1
                            (1) Hanoi(2,’a’,’c’,’b’)=(1)-2 move(‘a’,’b’)------------------------------2
                                                           (1)-3 Hanoi(1,’c’,’a’,’b’) =move(‘c’,’b’)--3
Hanoi(3,’a’,’b’,’c’)= (2) move(‘a’,’c’)---------------------------------------------------------------4      
                                                           (3)-1 Hanoi(1,’b’,’c’,’a’)=move(‘b’,’a’)---5
                            (3) Hanoi(2,’b’,’a’,’c’)=(3)-2 move(‘b’,c’)--------------------------------6
                                                           (3)-3 Hanoi(1,’a’,’b’,’c’)=move(‘a’,’c’)---7

其实递归的整个 执行流程 我都晓得...  我在第5楼的 时候 就把整个递归流程 全部叙述了.
我觉得话呢 好多人 还是没真正的回答到 真正的疑惑  例如  f2不一定就是第二根(b)柱子的 只是放了盘子的柱子.

这些不解决的话，  如果 光从 伪代码 去看的话 好难想 ！！！！很容易会成一种 直线的思维......

最后的话呢，自己反复挣扎了 ，终于可以把代码和思想相理解的解释了
希望 跟我一样遇到此问题的人 有个帮助.............
void hannuota(int n,char f1,char f2,char f3)
{
    if (1==n)                    // 其实 这里相当于一个发动点 表示 将第1个 到第 n个和n前面的盘子开始依次移动   
   {
        printf("编号%d 从%c移动到%c\n",n,f1,f3);                  
    }
    else
    {
        hannuota(n-1,f1,f3,f2);//这里的话 这种颠倒的使得符合游戏规则 可以 怎么说呢 ,例:n-1个 需要先将n-2个放B上 然后因为这种的参数颠倒可以使n-2放在n-1个上 可以依次类推      
        printf("编号%d 从%c移动到%c\n",n,f1,f3); //将第n前面的直接放在不一定是c上的位置，就如我前面所说的颠倒性.但第n个绝对是c的因为刚开始调用就指定了的
        hannuota(n-1,f2,f1,f3); //然后这里的f2其实是就是 放了盘子的柱子上 不一定是b的（只是表示着 放了n-1盘子的柱子上） 移到c上                        
    }
    return;
}