Question

我试图在矩阵中递归地找到一个数字。

public class Test2 {
static char arry [][] = {{'#','#','#'},
                         {'#',' ',' '},
                         {'#',' ','#'},
                         {'#',' ','1'},
};

public static void main(String args []){
    recursion(2,1);

}

private static void recursion(int row, int col) {
    if(arry[row][col]=='1' && isInBound(row,col)==true){
        System.out.println("Found at " + row + " " + col);
    }else if ((isInBound(row,col)==true)&& arry[row][col]==' '){
        recursion(row,col+1);
        recursion(row,col-1);
        recursion(row-1,col);
        recursion(row+1,col);

    }

}

private static boolean isInBound(int row, int col) {
    boolean bol = false;
    if(row<= arry.length && col <= arry[0].length){
        bol = true;
    }

    return bol;
}

}

我试图以这样的方式制作节目，以便我可以从任何位置开始。例如我从这个程序的2,1位开始。我得到了一个超出范围的例外。在使用try catch循环时，代码有时适用于某些输入。除非绝对必要，否则我不想使用try catch。我也试图在矩阵中寻找所有4个方向。那是我的问题开始的地方我已经走出界限了。

Answer 1

只使用到目前为止所编写的内容，您应首先使用isInBound检查索引是否有效，如果超出界限则立即检查return;。当前检查边界的方式，在测试边界之前总是使用边界，这意味着无论你从哪里开始，你总是会遇到越界异常。

E.g。在private static void recursion(..)的开头，添加以下内容：

if(!isInBound(row,col)) {
    return;
}

并且不需要后续的数组绑定测试。因此，递归调用对无效边界的任何递归调用都将返回，而不会产生越界异常。

Answer 2

private static void recursion(int row, int col) {
    if(arry[row][col]=='1'){
        System.out.println("Found at " + row + " " + col);
    }
    else if (arry[row][col]=='#'){
        return;
    }
    if (isInBound(row,col + 1)){
        recursion(row,col+1);
    }
    if(isInBound(row, col - 1)){
        recursion(row, col - 1)
    }
    if(isInBound(row -1, col)){
        recursion(row-1,col);
    } 
    if(isInBound(row + 1, col) {
        recursion(row+1,col);
    }
    else {
        return;
    }
}

假设您在找到＃时跳过＃。

Answer 3

这有效：

public class Test2 {
    static char arry[][] = { { '#', '#', '#' }, { '#', ' ', ' ' },
            { '#', ' ', '#' }, { '#', ' ', '1' }, };
    static boolean[][] visited = new boolean[arry.length][arry[0].length];

    public static void main(String args[]) {
        // fill visited array
        for (int i = 0; i < visited.length; i++) {
            for (int j = 0; j < visited[0].length; j++) {
                visited[i][j] = false;
            }
        }

        recursion(2, 1);

    }

    private static void recursion(int row, int col) {
        if (!isInBound(row, col) || visited[row][col])
            return;
        visited[row][col] = true;

        if (arry[row][col] == '1') {
            System.out.println("Found at " + row + " " + col);
            return;
        } else if (arry[row][col] == ' ') {
            recursion(row, col + 1);
            recursion(row - 1, col);
            recursion(row + 1, col);
            recursion(row, col - 1);

        }

    }

    private static boolean isInBound(int row, int col) {
        boolean bol = false;
        if (row < arry.length && col < arry[0].length && col >= 0 && row >= 0) {
            bol = true;
        }

        return bol;
    }
}

递归地在2d矩阵中找到一个元素

3 个答案: