函数递归经典例题（汉诺塔和青蛙跳台阶详解）

上一篇和大家分享了函数递归相关的知识，那么这一篇就和大家分享两个函数递归的经典例题：汉诺塔问题和青蛙跳台阶的问题。

1. 汉诺塔问题

1.1 了解汉诺塔问题

汉诺塔问题源自印度一个古老的传说，印度教的“创造之神”梵天创造世界时做了 3 根金刚石柱，其中的一根柱子上按照从小到大的顺序摞着 64 个黄金圆盘。梵天命令一个叫婆罗门的门徒将所有的圆盘移动到另一个柱子上，移动过程中必须遵守以下规则：

①每次只能移动柱子最顶端的一个圆盘；

②每个柱子上，小圆盘永远要位于大圆盘之上；

简单来讲就是：给定三根柱子，记为 A，B，C，其中 A 柱子上有 n 个圆盘，从上到下编号为 0 到 n−1 ，且上面的圆盘一定比下面的圆盘小。问：将 A 柱上的圆盘经由 B 柱移动到 C 柱最少需要多少次？移动时要注意：1.一次只能移动一个圆盘 2.大圆盘不能压在小圆盘上面。

1.2 分析汉诺塔问题

为了方便讲解，我们将 3 个柱子分别命名为A柱、B柱和C柱。实际上，解决汉诺塔问题是有规律可循的：（由于我不会制作动图，等学会给大家补上动图，更加方便理解）

 当起始柱上只有 1 个圆盘时，我们可以很轻易地将它移动到目标柱上。

当起始柱上有 2 个圆盘时，移动过程是：先将A柱上的 1 个圆盘移动到B柱上，然后将A柱上遗留的圆盘移动到C柱上，最后将B柱上的圆盘移动到C柱上。

当起始柱上有 3 个圆盘时，仔细思考会发现，移动过程和 2 个圆盘的情况类似：先将A柱上的 2 个圆盘移动到B柱上，然后将A柱上遗留的圆盘移动到C柱上，最后将B柱上的圆盘移动到C柱上。

在汉诺塔问题中，当圆盘个数不大于 3 时，多数人都可以轻松想到移动方案，随着圆盘数量的增多，汉诺塔问题会越来越难。也就是说，圆盘的个数直接决定了汉诺塔问题的难度，解决这样的问题可以尝试用分治算法，将移动多个圆盘的问题分解成多个移动少量圆盘的小问题，这些小问题很容易解决，从而可以找到整个问题的解决方案。通过分析以上 3 种情况的移动思路，可以总结出一个规律：对于 n 个圆盘的汉诺塔问题，移动圆盘的过程是：

1. 将起始柱上的 n-1 个圆盘移动到辅助柱上；
2. 将起始柱上遗留的 1 个圆盘移动到目标柱上；
3. 将辅助柱上的所有圆盘移动到目标柱上。

由此，n 个圆盘的汉诺塔问题就简化成了 n-1 个圆盘的汉诺塔问题。按照同样的思路，n-1 个圆盘的汉诺塔问题还可以继续简化，直至简化为移动 3 个甚至更少圆盘的汉诺塔问题。

1.3 代码的实现

如下是解决汉诺塔问题的 C 语言程序：

#include<stdio.h>
void hanoi(int num,char sou,char tar,char aux)
{
  static int i=1;//统计移动次数
  if(num==1)//当只有一个圆盘时，直接从A柱转移到C柱
   {
     printf("第%d次：从%c转移到%c\n",i,sou,tar);
     i++;
   }
  else
   {
     hanoi(num-1,sou,aux,tar);//递归调用hanoi（）函数，将n-1个圆盘从A柱转移到B柱上
     printf("第%d次：从%c转移到%c\n",i,sou,tar);
     i++;
     hanoi(num-1,aux,tar,sou);//递归调用hanoi（）函数，将n-1个圆盘从B柱转移到C柱上
   }
}
int main()
{
  hanoi(3,'A','B','C');//以3个圆盘为例
  return 0;
}

运行一下看看结果：

再给大家分享一个JAVA实现的代码：

public class project1  
public static int i = 1;
    public static void hanoi(int num, char sou, char tar, char sux) 
       {
        // 如果圆盘数量仅有 1 个，则直接从A柱移动到C柱
        if (num == 1) 
          {
            System.out.println("第" + i + "次:从" + sou + "移动到" + tar);
            i++;
          } 
        else 
          {
            // 递归调用 hanoi() 函数，将 num-1 个圆盘从A柱移动到B柱上
            hanoi(num - 1, sou, sux, tar);
            System.out.println("第" + i + "次:从" + sou + "移动到" + tar);
            i++;
            // 递归调用 hanoi() 函数，将B柱上的 num-1 圆盘移动到C柱上
            hanoi(num - 1, sux, tar, sou);
          }
       }
    public static void main(String[] args)
   {
        // 以移动 3 个圆盘为例
        hanoi(3, 'A', 'B', 'C');
    }
}

 运行一下看看结果：

2. 青蛙跳台阶问题

2.1 了解青蛙跳台阶问题

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法？

2.2 分析青蛙跳台阶问题

当只有一个台阶时，只有一种跳法。

当有2级台阶时，有两种跳法。

当有3级台阶时，有三种跳法。

当有4级台阶时，有五种跳法。

...

我们可以发现下面这个规律：

 类似于斐波那契数。

2.3 代码的实现

使用递归实现：

#include<stdio.h>
int Fn(int n)
{
  if(n<=2)
   return n;
  else
   return Fn(n-1+Fn(n-2));
}
int main()
{
  int n=0;
  printf("请输入台阶的级数：");
  scanf("%d",&n);
  printf("共有%d种跳法",Fn(n));
  return 0;
}

使用循环实现：

#include<stdio.h>
int Fn(int n)
{
  int a=1,b=2,c=0;
  if(n==1)
    return 1;
  else if(n==2)
    return 2;
  else
   {
     for(int i=3;i<=n;i++)
      {
        c=a+b;
        a=b;
        b=c;
      }
     return c;
   }
}
int main()
{
	int n = 0;
	printf("请输入台阶的级数:");
	scanf("%d",&n);
	printf("一共有%d种跳法", Fn(n));
	return 0;
}

 

函数递归的两个经典例题就和大家分享到这里了，如果大家有什么疑惑或者其他的见解欢迎评论区留言。