java - 在java中的二维字符数组中查找单词。如果某些部分没有被注释掉，为什么我会遇到搜索问题？

Question

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

当我注释掉除一个方向之外的所有方向时，例如，我试图找到一个对角线延伸的单词，它可以工作，但是当我尝试运行它时，所有方向都没有被注释掉，只有几个单词出现返回我正在尝试寻找的内容。

我要查找的单词列表是:

SCALA
JAVA
ALGOS
ALGORITHM
SLUG
SLUR
GOES
TURTLE

当我运行我的程序时，它找到了 SCALA 和 JAVA，但在尝试查找 ALGOS 后却给了我一个索引越界异常。然而，当我注释掉所有方向并搜索我知道 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

看完之后，尝试改变它:
// search right
if (col + (word.length()-1) <= board[row].length) {

对此:
// search right
if (col + (word.length()-1) < board[row].length) {

编辑:

此外，更改此:
//search down
if (row + (word.length()-1) <= board[row].length) {

对此:
//search down
if (row + (word.length()-1) < board.length) {

这个:

// search diagonal up to right
if((row - (word.length()-1) <= 0) && (col + (word.length()-1) <= board[row].length)) {对此: // search diagonal up to right
if((row - (word.length()-1) >= 0) && (col + (word.length()-1) < board[row].length)) {

这个:
// search diagonal down to right
if((row + (word.length()-1) <= board[row].length) && (col + (word.length()-1) <= board[row].length)

对此:
// search diagonal down to right
if((row + (word.length()-1) < board.length) && (col + (word.length()-1) <= board[row].length)

这个:
// search diagonal down to left
if((row + (word.length()-1) <= board[row].length) && (col - (word.length()-1) >=0)) {

对此:
// search diagonal down to left
if((row + (word.length()-1) < board.length) && (col - (word.length()-1) >=0)) {

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