青蛙跳台阶(普通版)循环+递归实现

这篇博客介绍了青蛙跳台阶问题,通过分析得出其解决方案与斐波那契数列的关系。给出了循环和递归两种代码实现方式。

青蛙跳台阶

1. 问题要求

有n阶台阶,一只青蛙一次只能跳1个台阶或者2个台阶,问青蛙跳上这个n阶台阶一共有多少种跳法。跳1个台或者跳2个台阶的顺序不一样,次数不一样都算不同的跳法。

2. 思路分析
  1. 如果只有1阶台阶,那么青蛙只需要跳一级便可以。共1种跳法。
    在这里插入图片描述

  2. 如果有2阶台阶。那么它可以跳1个台阶,再跳1个台阶,这是第一种跳法。或者直接跳2个台阶。共2种跳法
    在这里插入图片描述

  3. 如果是3阶台阶。第一种跳法可以1个台阶1个台阶的跳(如图红线),第二种跳法可以跳1个台阶再跳2个台阶(如图蓝线),第三种跳法可以跳2个台阶再跳一个台阶(如图绿线)。共3种跳法
    在这里插入图片描述

  4. 4阶台阶:一共有5种跳法
    在这里插入图片描述

  5. 由此不难发现,

  • 1阶------ n1 = 1
  • 2阶------ n2 = 2
  • 3阶------ n3 = n2 + n1 = 3
  • 4阶------ n4 = n3 + n2 = 5
  • n阶------ n = (n - 1) + (n - 2)
  1. 所以,看到这里,相信你们也发现这其实就是个初值不一样的“斐波那契数列”,fn = f(n -1)+ f(n -2)。而初值f1 = 1,f2 = 2。
3. 代码实现
  • 循环实现:
package day4_10_14;

/**
 * @author:fover
 * @date:2020/10/14 14:54
 * @version:1.0
 * @function:青蛙跳台阶
 */
public class Home3 {
    public static void main(String[] args) {
        System.out.println("青蛙跳10级台阶有"+frog(10)+"种跳法");
    }
    public static int frog(int n) {
        int f1 = 1;
        int f2 = 2;
        int f3 = 0;
        if (n == 1 || n == 2) {
            return n;
        } else {
            for (int i = 3; i <= n; i++) {
                f3 = f1 + f2;
                f1 = f2;
                f2 = f3;
            }
        }
        return f3;
    }
}
  • 递归实现
package day4_10_14;

/**
 * @author:fover
 * @date:2020/10/14 15:08
 * @version:1.0
 * @function:青蛙跳台阶--递归
 */
public class Home3_other {
    public static void main(String[] args) {
        System.out.println("青蛙跳10级台阶有"+frog(10)+"种跳法");
    }
    public static int frog(int n) {
        if (n == 1 || n == 2) {
            return n;
        }
        return frog(n - 1) + frog(n - 2);
    }
}
<think>我们正在讨论青蛙跳台问题的递归实现。根据引用[1]、[3]和[5],青蛙跳台问题是一个经典的递归问题。问题描述如下:一只青蛙一次可以1台阶,也可以上2台阶。求该青蛙上一个n台阶总共有多少种法。 递归思路: 1. 当台阶数n=1时,只有1法(直接1)。 2. 当台阶数n=2时,有2种法(连续两次1,或者一次2)。 3. 对于n>2的情况,青蛙在第一次的时候有两种选择: - 1,此时剩下的台阶数为n-1法为f(n-1) - 2,此时剩下的台阶数为n-2,法为f(n-2) 因此,总的法为f(n) = f(n-1) + f(n-2) 这实际上就是斐波那契数列。 引用[3]和[5]给出了递归实现Java代码。下面我将根据这些引用,整理出一个完整的递归实现示例,并简要说明。 ### Java递归实现青蛙跳台问题 ```java public class FrogJump { // 递归方法 public static int jump(int n) { if (n == 1) { return 1; } else if (n == 2) { return 2; } else { return jump(n - 1) + jump(n - 2); } } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("请输入台阶数:"); int n = scanner.nextInt(); System.out.println(n + "台阶一共有" + jump(n) + "种法"); } } ``` #### 代码说明: 1. `jump`方法是递归函数,参数`n`表示台阶数。 2. 当`n=1`时,返回1(只有1法)。 3. 当`n=2`时,返回2(有2种法)。 4. 当`n>2`时,返回`jump(n-1) + jump(n-2)`,即1后剩下的台阶法与2后剩下的台阶法之和。 #### 注意: 递归实现虽然简洁,但存在重复计算的问题。例如,计算`jump(5)`时会计算`jump(4)`和`jump(3)`,而计算`jump(4)`时又会计算`jump(3)`和`jump(2)`,这样`jump(3)`就被重复计算了。当n较大时,重复计算会很多,效率较低。 ### 优化: 可以考虑使用动态规划(非递归)或记忆化递归来优化。引用[2]和[4]给出了非递归(迭代)的实现方式,通过保存中间结果避免了重复计算。 ### 示例:非递归实现(迭代) ```java public static int frogJump(int n) { if (n == 1 || n == 2) { return n; } int a = 1; // 表示f(n-2) int b = 2; // 表示f(n-1) int c = 0; // 表示f(n) for (int i = 3; i <= n; i++) { c = a + b; a = b; b = c; } return c; } ``` ### 总结: 递归实现青蛙跳台问题代码简单,容易理解,但效率不高,适合小规模问题。对于大规模台阶数,建议使用迭代方法或记忆化递归。 §§相关问题§§ 1. 青蛙跳台问题的递归实现存在什么缺点? 2. 如何优化青蛙跳台问题的递归算法? 3. 除了1和2,如果青蛙可以更多(如3、4等),递归公式应该如何修改? </think>### Java递归实现青蛙跳台问题 青蛙跳台问题是一个经典的递归算法问题,描述如下:一只青蛙一次可以1或2台阶,求上n台阶有多少种法。 #### 递归实现原理 设$f(n)$为上n台阶法数量: 1. $n=1$时:$f(1)=1$(直接1) 2. $n=2$时:$f(2)=2$(连续两次1,或直接2) 3. $n≥3$时:$f(n) = f(n-1) + f(n-2)$ (第一次1时剩余$n-1$,第一次2时剩余$n-2$) #### Java递归实现代码 ```java public class FrogJump { public static int jump(int n) { if (n == 1) { return 1; // 基础情况1 } else if (n == 2) { return 2; // 基础情况2 } else { return jump(n - 1) + jump(n - 2); // 递归调用 } } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("请输入台阶数 n: "); int n = scanner.nextInt(); System.out.println(n + "台阶共有 " + jump(n) + " 种法"); } } ``` #### 代码说明 1. **递归终止条件**: - 当$n=1$时返回1 - 当$n=2$时返回2 2. **递归逻辑**: - 对于$n \geq 3$的情况,分解为$jump(n-1) + jump(n-2)$ 3. **时间复杂度**:$O(2^n)$(存在重复计算) 4. **空间复杂度**:$O(n)$(递归栈深度) #### 执行示例 - 输入:`n=3` → 输出:3 (法:1+1+1, 1+2, 2+1) - 输入:`n=4` → 输出:5 (法:1+1+1+1, 1+1+2, 1+2+1, 2+1+1, 2+2) ### 优化建议 递归实现虽然简洁,但存在重复计算问题(如计算$jump(5)$时需要重复计算$jump(3)$)。可采用以下优化: 1. **记忆化递归**:用数组存储已计算结果 2. **迭代法**:使用循环代替递归(参考引用[2]和[4]) 3. **动态规划**:自底向上计算避免递归开销 [^1]: 青蛙跳台递归思路分析 [^2]: 非递归实现代码参考 [^3]: 基础递归实现 [^4]: 迭代法优化实现
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值