递归的经典问题

一、斐波那契数列

有一个数列 1，1，2，3，5，8，13 ...，给你一个整数 n，用递归的方式求出它的值。

思路分析：

（1）当 n 等于 1 或 n 等于 2 时，斐波那契数是 1

（2）当 n > 2 时，斐波那契数是前两个数的和

根据规律可写出如下代码：

int fibonacci(int n)
{
    if(n == 1 || n == 2)
        return 1;
    else
    {
        return fibonacci(n - 1)+fibonacci(n - 2);
    }
}

 

二、猴子吃桃

有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个，以后每天猴子都吃其中的一半，然后再多吃一个，当到第十天时，猴子想再吃（即还没吃），却发现只有一个桃子了。求最初一共有多少个桃子。

 思路分析（逆推）：

（1）day = 10 时，有 1 个桃子

（2）day = 9 时，有 （ day 10 + 1 ）* 2 = 4 个桃子

（3）day = 8 时，有（ day 9 + 1 ）* 2 = 10 个桃子

得出规律是 前一天的桃子 =（ 后一天的桃子 + 1 ）* 2，代码如下

int peach(int day)
{
    if(day == 10)
        return 1;
    else if(day >= 1 && day < 10)
    {
        return (peach( day + 1 ) + 1) * 2;
    }
    else
    {
        return -1;            //不在范围内的天数返回-1
    }
}

 

三、迷宫问题

迷宫问题求解得到的路径与设置的找路策略（这里规定找路顺序为 下—>右—>上—>左）有关

因为我们是递归的找路，我们这里给出几点规定：

1 . 规定 map 数组各个值的含义：0 表示可以走，1 表示障碍物，2 表示探测过可以走，3 表示探测过但是走不通（即死路）

2 . 确定递归出口，当 map [ 6 ] [ 6] = 2 时，说明找到通路，否则继续找

思路分析：

（1）先创建迷宫，用二维数组表示，初始化二维数组

int [][] map = new int[8][8];
for(int i = 0 ; i < map.length ; i++)
{
    map[0][i] = 1;
    map[7][i] = 1;
    map[i][0] = 1;
    map[i][7] = 1;
}
map[2][3] = 1;
map[3][5] = 1;
map[4][2] = 1;
map[6][5] = 1;

创建好的迷宫如图所示：

（2）定义 findWay 方法去找出迷宫的路径，如果找到，返回 true，否则返回 false

boolean findWay(int [][] map,int i,int j)//i,j 表示当前位置
{
    if(map[6][6] == 2)     //递归出口
        return true;
    else
    {
        if(map[i][j] == 0) //当前位置没走过，可以走
        {
            map[i][j] = 2; //先假定这个位置可以走通

            //使用找路策略来确定该位置是否真的可以走通
            if( findWay (map, i+1, j ))      //先走下
                return true；
            else if( findWay (map, i, j+1 )) //右
                return true；
            else if( findWay (map, i-1, j )) //上
                return true；
            else if( findWay (map, i, j-1 )) //左
                return true；
            else
            {
                map[i][j] = 3;
                return false;
            }
            
        }else{            //map[i][j] = 1, 2, 3
             return flase; 
        }
    }
}

 

四、汉诺塔问题

将全部盘子从 A 塔搬运到 C 塔，可以借助 B 塔，并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘 

思路分析：

（1）当只有一个盘子时，将 A 塔上的盘子直接移动到 C 塔

（2）当有多个盘子时，除了 A 塔最下面的一个盘子，其余的盘子都移到 B 塔上，然后就可以直接将 A 塔上的一个盘子直接移动到 C 塔了

（3）然后再借助 A 塔，将 B 塔上的所有盘子移动到 C 盘

代码如下：

public void move(int num,char a,char b,char c)   //num表示要移动盘子的个数
{
    if(num == 1)
        System.out.println(a + "——>" + c);
    else
    {
        move(num-1, a, c, b);    //先移动上面所有盘到b,借助c
        System.out.println(a + "——>" + c);//把最下面的这个盘，移到c
        move(num-1, b, a, c);    //把b塔上的所有盘，借助a，移动到c
    }
}