递归的应用

递归是一种编程技术，它利用一个方法调用自身来满足其整个作用

以下介绍两个递归的应用：

1.穿越迷宫（在栈的实现与应用中已经用栈实现了，这里使用递归进行实现）

package xidian.sl.sortingandsearching;

public class Maze2 {
    //表示移动有效，网格方块会从1变成3
    private final int TRIED = 3;
    private final int PATH = 7;
    //用二维数组来模拟迷宫，1表示路径畅通，0表示路径不同
    private int[][] grid = {{1,1,1,0,1,1,0,0,0,1,1,1,1},
                            {1,0,1,1,1,0,1,1,1,1,0,1,1},
                            {0,0,0,0,1,0,1,0,1,0,1,0,0},
                            {1,1,1,0,1,1,1,0,1,0,1,1,1},
                            {1,0,1,0,0,0,0,1,1,1,0,0,1},
                            {1,0,1,1,1,1,1,1,0,1,1,1,1},
                            {1,0,0,0,0,0,0,0,0,0,0,0,0},
                            {1,1,1,1,1,1,1,1,1,1,1,1,1}    };
    
    public boolean traverse(int row, int column){
        boolean done = false;
        
        if(valid(row, column)){
            //标志该位置有效
            grid[row][column] = TRIED;
            //判定是否已经到达右下角，即走出迷宫
            if(row == grid.length-1 && column == grid[0].length-1){
                done = true;
            }else{
                //向下走
                done = traverse(row + 1, column);                //down
                if(!done){
                    //向右走
                    done = traverse(row, column + 1);            //right
                }
                if(!done){
                    //向上走
                    done = traverse(row - 1, column);            //up
                }
                if(!done){
                    //向左走
                    done = traverse(row, column - 1);            //left
                }
            }
            if(done){
                grid[row][column] = PATH;
            }
        }
        return done;
    }
    //用于判断指定行/列的移动是否有效，当移动仍然处于网格内并且指定位置处存放着1，则认为此次移动有效，返回true
    private boolean valid(int row, int column){
        boolean result = false;
        
        if(row >= 0 && row < grid.length && column >= 0 && column < grid[row].length){
            if(grid[row][column] == 1){
                result = true;
            }
        }
        return result;
    }
    //重写toString方法
    public String toString(){
        String result = "\n";
        for(int row = 0; row < grid.length; row++){
            for(int column = 0; column < grid[row].length; column++){
                result += grid[row][column] + "";
            }
            result += "\n";
        }
        return result;
    }
}

测试类：

package xidian.sl.sortingandsearching;

/**
 * 递归解决穿越迷宫问题
 * */
public class MazeSearch {
    public static void main(String[] args) {
        Maze2 labyrinth = new Maze2();
        System.out.println(labyrinth);
        
        if(labyrinth.traverse(0, 0)){
            System.out.println("成功穿越");
        }else{
            System.out.println("没有可能穿越的路");
        }
        
        System.out.println(labyrinth);
    }
}

2.大家肯定玩过的游戏（汉诺塔）

package xidian.sl.sortingandsearching;

public class TowersOfHanoi {
    //记录汉诺塔总共多少张圆盘
    private int totalDisks;
    
    public TowersOfHanoi(int disks){
        totalDisks = disks;
    }
    
    public void slove(){
        moveTower(totalDisks, 1, 3, 2);
    }
    
    private void moveTower(int numDisks, int start, int end, int temp){
        if(numDisks == 1){
            moveOneDisk(start, end);
        }else{
            moveTower(numDisks - 1, start, temp, end);
            moveOneDisk(start, end);
            moveTower(numDisks - 1, temp, end, start);
        }
    }
    
    private void moveOneDisk(int start, int end){
        System.out.println("移动一张盘子，从 "+start+" 到"+end);
    }
}

测试类：

package xidian.sl.sortingandsearching;

public class SolveTowers {

    /**
     * @param args
     */
    public static void main(String[] args) {
        TowersOfHanoi towers = new TowersOfHanoi(4);
        towers.slove();
    }

}