面试中常见递归题目 Java版

 package math;

public class RevertANumber {

    /*
     * 一列数的规则如下: 1、1、2、3、5、8、13、21、34...... 求第30位数是多少, 用递归算法实现。
     * */
    static int find30(int n){
        if (n <= 0)
            return 0;
            else if(n > 0 && n <= 2)
            return 1;
        return find30(n-1)+find30(n-2);
           
    }
   
   
    /*
     * 将一整数逆序后放入一数组中(要求递归实现) Ex : 1234 变为 {4,3,2,1}
     */

    static int revert(int rs[], int i, int number) {
        if (i < rs.length) {
            rs[i] = number % 10;
            number = (number - number % 10) / 10;
            return revert(rs, i + 1, number);
        } else {
            return 0;
        }

    }

    /*
     * 递归实现回文判断(如:abcdedbca就是回文,判断一个面试者对递归理解的简单程序)
     */
    static boolean loopWord(String str, int i) {

        if (str.charAt(i) == str.charAt(str.length() - 1 - i)) {
            if (i == (str.length() + 1) / 2)
                return true;
            return loopWord(str, i + 1);
        } else {
            return false;
        }
    }

    /*
     * 分解成质因数(如435234=251*17*17*3*2,据说是华为笔试题)
     */

    static int dividePrimeToFactors(int num, int factor) {

        while ((factor < num) && (num % factor != 0))
            factor++;
        System.out.print(factor + " ");
        num = num / factor;
        if (factor >= num)
            return factor;// 结束判断
        return dividePrimeToFactors(num, factor + 1);

    }

    public static void main(String[] args) {
      
        System.out.println(find30(30));
       
        int number = 1234;
        int[] rs = new int[(number + "").length()];
        revert(rs, 0, number);
        for (int i = 0; i < rs.length; i++) {
            System.out.print(rs[i]);
        }

        System.out.println(loopWord("1234321", 0));

        dividePrimeToFactors(435234, 2);

    }

}



================================================================================
//递归 寻找迷宫出路

package math;

public class Maze {

    int MAX_SIZE = 8;
    int h[] = { 0, 1, 0, -1 };
    int v[] = { -1, 0, 1, 0 };
    // 这样组成了向周围4个方向 依次是 ← ↓ → ↑

    char Maze[][] = {
            { 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' },
            { ' ', ' ', ' ', ' ', ' ', 'X', 'X', 'X' },
            { 'X', ' ', 'X', 'X', ' ', ' ', ' ', 'X' },
            { 'X', ' ', 'X', 'X', ' ', 'X', 'X', ' ' },
            { 'X', ' ', 'X', 'X', 'X', 'X', 'X', 'X' },
            { 'X', ' ', 'X', 'X', ' ', ' ', ' ', 'X' },
            { 'X', ' ', ' ', ' ', ' ', 'X', ' ', ' ' },
            { 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X' } };

    void FindPath(int X, int Y) {

        if (X == MAX_SIZE || Y == MAX_SIZE) {//表明指针已经移动到边缘 准备输出
            for (int i = 0; i < MAX_SIZE; i++) {
                for (int j = 0; j < MAX_SIZE; j++) {
                    if (j < MAX_SIZE - 1) {
                        System.out.print(Maze[i][j] + " ");
                    } else {//到达列末尾 准备换行
                        System.out.println(Maze[i][j]);
                    }
                }
            }
        } else {
                checkAround(X, Y);
        }
    }
   
    void checkAround(int X, int  Y){
        //把寻找周围4个路径放在前面 这样可能不好理解
//        for (int k = 0; k < 4; k++) {//上下左右四个方向扫描
//            if (X >= 0 && Y >= 0 && Y < MAX_SIZE && X < MAX_SIZE
//                    && ' ' == Maze[X][Y]) {
//                Maze[X][Y] = '.';
//                FindPath(X + v[k], Y + h[k]);// 检查周围4个方向是不是也是o
//                Maze[X][Y] = ' ';
//            }
//        }
       
        if (X >= 0 && Y >= 0 && Y < MAX_SIZE && X < MAX_SIZE
                && ' ' == Maze[X][Y]) {
            Maze[X][Y] = '.';
            for (int k = 0; k < 4; k++) {
                FindPath(X + v[k], Y + h[k]);// 检查周围4个方向是不是也是o   
            }
            Maze[X][Y] = ' ';//沿着路线走 最终有的路可能是走不通 标记回来
        }
    }

    public static void main(String[] args) {
        Maze maze = new Maze();
        maze.FindPath(1, 0);// 从 Maze[1][0]进入
    }
}
### 递归算法的定义与特点 递归算法是一种在函数内部调用自身的算法。它通常用于解决可以分解为多个相同子问题的问题,例如斐波那契数列、阶乘计算等。递归算法的关键在于定义递归的终止条件和递归调用的逻辑。递归算法的优点在于代码简洁,逻辑清晰,但缺点是可能导致大量的重复计算,增加时间复杂度和空间复杂度。 ### 递归算法的应用场景 递归算法广泛应用于各种数据结构和算法中。例如,在树和图的遍历中,递归算法可以简化代码逻辑,使得代码更易理解和维护。此外,递归算法也常用于解决分治问题,如快速排序、归并排序等。在实际应用中,递归算法还可以用于解决动态规划问题,如背包问题、最长公共子序列问题等。 ### 递归算法的优化 递归算法的性能优化通常通过减少重复计算来实现。一种常见的优化方法是使用记忆化搜索,即将已经计算过的结果存储起来,避免重复计算。另一种优化方法是使用尾递归,通过将递归调用放在函数的最后一步,可以减少栈的深度,避免栈溢出问题。 ### 递归算法与栈溢出 递归算法的一个主要问题是可能导致栈溢出。这是因为每次递归调用都会在调用栈上分配一个新的栈帧,如果递归的深度过深,可能会导致调用栈溢出。为了避免栈溢出问题,可以通过增加JVM的栈大小或者将递归算法转换为迭代算法来解决。 ### 示例代码 以下是一个计算斐波那契数列的递归算法示例: ```java public class Fibonacci { public static int fibonacci(int n) { if (n == 0) { return 0; } else if (n == 1) { return 1; } else { return fibonacci(n - 1) + fibonacci(n - 2); } } public static void main(String[] args) { System.out.println("Fibonacci(10) = " + fibonacci(10)); } } ``` 上述代码中,`fibonacci`方法通过递归调用自身来计算斐波那契数列的第`n`项。由于递归算法的特性,该方法在计算较大的`n`值时会导致大量的重复计算,从而影响性能。 ### 优化示例 为了优化上述递归算法,可以使用记忆化搜索来存储已经计算过的结果: ```java import java.util.HashMap; import java.util.Map; public class FibonacciOptimized { private static Map<Integer, Integer> memo = new HashMap<>(); public static int fibonacci(int n) { if (n == 0) { return 0; } else if (n == 1) { return 1; } else if (memo.containsKey(n)) { return memo.get(n); } else { int result = fibonacci(n - 1) + fibonacci(n - 2); memo.put(n, result); return result; } } public static void main(String[] args) { System.out.println("Fibonacci(10) = " + fibonacci(10)); } } ``` 通过使用记忆化搜索,上述代码显著减少了重复计算,提高了递归算法的性能[^1]。
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值