在Java中查找2D字符数组中的单词。如果某些部分没有被注释掉，为什么我会有搜索问题？

Question

我有一个从字符网格中的单词数组中搜索单词的方法。它搜索从左到右、从右到左、从上到下、从下到上、从左垂直向上、从右垂直向上、从左垂直向下和从右垂直向下。

当我注释掉除一个以外的所有方向时，例如，我试图找到一个对角方向的单词，它有效，但当我试图运行它时，所有方向都没有注释掉，只有几个单词返回来，我试图搜索。

SCALA
JAVA
ALGOS
ALGORITHM
SLUG
SLUR
GOES
TURTLE

当我运行我的程序时，它找到了SCALA和JAVA，但当它试图寻找algos时，它给了我一个索引越界异常。然而，当我注释掉所有的方向，并搜索我知道阿尔戈斯所在的方向时，它不会给我任何问题。

我的代码有什么问题，它做到了这一点，我如何修复它？谢谢你。

public static String findWord(char[][]board, String word) {
        int counter = 0;

        for (int row = 0; row < board.length; row++) {
            for (int col = 0; col < board[row].length; col++) {

                // search to the right
                    if (col + (word.length()-1) <= board[row].length) {
                        boolean foundWord = true;

                        for (int letters = 0; letters < word.length(); letters++) {
                            if (word.charAt(letters) != board[row][col+letters]) {
                                foundWord = false;
                                break;
                            }
                        }
                        if(foundWord) {
                            return word + " Found at: " + Arrays.toString(new int[] {row,col});
                        }
                    } // end search to the right

                    // search to the left
                    if (col - (word.length()-1) >= 0) {
                        boolean foundWord = true;

                        for (int letters = 0; letters < word.length(); letters++) {
                            if (word.charAt(letters) != board[row][col-letters]) {
                                foundWord = false;
                                break;
                            }
                        } 
                        if(foundWord) {
                            return word + " Found at: " + Arrays.toString(new int[] {row,col});
                        }
                    } // end search to the left

                    // search down
                    if (row + (word.length()-1) <= board[row].length) {
                        boolean foundWord = true;

                        for (int letters = 0; letters < word.length(); letters++) {
                            if (word.charAt(letters) != board[row+letters][col]) {
                                foundWord = false;
                                break;
                            }
                        }
                        if(foundWord) {
                            return word + " Found at: " + Arrays.toString(new int[] {row,col});
                        } 
                    } // end search down

                    // search up
                    if (row - (word.length()-1) >= 0) {
                        boolean foundWord = true;

                        for (int letters = 0; letters < word.length(); letters++) {
                            if (word.charAt(letters) != board[row-letters][col]) {
                                foundWord = false;
                                break;
                            }
                        }
                        if (foundWord) {
                            return word + " Found at: " + Arrays.toString(new int[] {row,col});
                        }
                    } // end search up 

                    // search diagonal up to right
                    if((row - (word.length()-1) <= 0) && (col + (word.length()-1) <= board[row].length)) {
                        boolean foundWord = true;

                        for (int letters = 0; letters < word.length(); letters++) {
                            if (word.charAt(letters) != board[row-letters][col+letters]) {
                                foundWord = false;
                                break;
                            }
                        }
                        if(foundWord) {
                            return word + " Found at: " + Arrays.toString(new int[] {row,col});
                        }
                    }
                    // end search diagonal up to right

                    // search diagonal up to left
                    if((row - (word.length()-1) >= 0) && (col - (word.length()-1) >= 0)) {
                        boolean foundWord = true;

                        for (int letters = 0; letters < word.length(); letters++) {
                            if (word.charAt(letters) != board[row-letters][col-letters]) {
                                foundWord = false;
                                break;
                            }
                        }
                        if(foundWord) {
                            return word + " Found at: " + Arrays.toString(new int[] {row,col});
                        }
                    } // end search diagonal up to left

                    // search diagonal down to right
                    if((row + (word.length()-1) <= board[row].length) && (col + (word.length()-1) <= board[row].length)) {
                        boolean foundWord = true;

                        for (int letters = 0; letters < word.length(); letters++) {
                            if (word.charAt(letters) != board[row+letters][col+letters]) {
                                foundWord = false;
                                break;
                            }
                        }
                        if(foundWord) {
                            return word + " Found at: " + Arrays.toString(new int[] {row,col});
                        }
                    } // end search diagonal down to right

                    // search diagonal down to left
                    if((row + (word.length()-1) <= board[row].length) && (col - (word.length()-1) >=0)) {
                        boolean foundWord = true;

                        for (int letters = 0; letters < word.length(); letters++) {
                            if (word.charAt(letters) != board[row+letters][col-letters]) {
                                foundWord = false;
                                break;
                            }
                        }
                        if(foundWord) {
                            return word + " Found at: " + Arrays.toString(new int[] {row,col});
                        }
                    }
                    // end search diagonal down to left 


            }
        }
        return word + " not found";
    } // end method findWord

Answer 1

只盯着它看一下，试着查一下://搜索右如果(col+(word.length（）-1)<=board[row].length）{

对此://如果(col+(word.length()-1) 搜索右侧

编辑：

//如果((row-(word.length()-1)<=0)&&(col+(word.length()-1)<=board[rought].length）{到这里://如果((row-(word.length()-1)>=0)&&(col+(word.length()-1) 搜索对角线到右

以下内容://如果((row+(word.length（）-1)<=board[row].length）&&(col+(word.length（）-1)<=board[row].length）则向右对角线搜索

对此://如果((row+(word.length（）-1) 则向下对角线向右搜索

以下内容://如果((row+(word.length（）-1)<=board[row].length）&&(col-(word.length（）-1)>=0)){

对此://如果((row+(word.length（）-1) =0)){

最后编辑：只是想解释一下这里发生了什么。你的检查范围只是一些简单的疏忽。我总是犯这些小错误，它们是最难发现的。但是，要注意你的界限。检查index<=board[row].length是否允许index成为数组的长度，而数组中根本不是索引（不包括关联数组！）。您还在一个点执行了if(index<=0&&...)，这将消除除第一行/列以外所有点的搜索的整个方向。