Java 2D数组中的单词搜索

Question

我正在尝试为课程作业创建一个简单的单词搜索，已经成功找到了从左到右（东）和从右到左（西）的搜索方法。但是我现在遇到了一个问题，我不知道如何从上向下（南）进行搜索。

我的代码可以针对其中一个文件进行操作，但第二个文件会返回一个ArrayIndexOutOfBoundsException错误。是否有什么特定的问题导致这段代码无法扩展？

我修正后的代码如下：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Scanner;

import wordSeek.GameBoard;

public class WordGame {

    private char[][] letters;
    GameBoard gb;

    public static void main(String[] args) {
        WordGame wg = new WordGame();
        wg.play();

    }

    public WordGame() {
        letters = readLettersFromFile();
        gb = new GameBoard(letters);

    }

    private void play() {
        Scanner s = new Scanner(System.in);
        String word;

        do {
            System.out.println("Enter word to find: ");
            word = s.next();

            // reset all highlighted tiles
            gb.reset();

            search(word);

        } while (!word.equals("QUIT"));

        gb.dispose();
    }

    // Nothing to be done above
    // Complete all the methods below

    private char[][] readLettersFromFile() {
        // From the data in the file Letters.txt determine the size (number of
        // rows and number of columns) for the letters array

        int rowCount = 0;
        int colCount = 0;
        char c;

        File file = new File("resources/Places.txt");

        Scanner fileScanner = null;
        try {
            fileScanner = new Scanner(file);
            } 
        catch (FileNotFoundException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        ArrayList<String> data = new ArrayList<String>();

        while(fileScanner.hasNextLine())
        {
            String line = fileScanner.nextLine();
            data.add(line);
        }

        fileScanner.close();
        rowCount = data.size();
        colCount = data.get(0).trim().length()/2+1;

        // Instantiate a two dimensional array of characters of the appropriate
        // size

        letters = new char [rowCount][colCount];

        // Populate the array with the letters in Letters.txt
        for (int i = 0; i < rowCount; i++) {
            String line = data.get(i);
            int pos = 0;
            for (int j = 0; j < colCount; j++) {
                letters[i][j] = line.charAt(pos);
                pos += 2;
            }

        }

        // return the array

        return letters;

    }

    private void search(String word) {
        System.out.println("Searching for " + word);

        //Call the other search methods below as needed
        searchIterativeEast(word);
        searchIterativeWest(word);
        searchIterativeSouth(word);
        searchIterativeNorth(word);
    }

    //The following four methods must employ ITERATION to search the game board
    private boolean searchIterativeEast(String word) {
        int k = 0;

        for (int i = 0; i < letters.length; i++) 
        {
            for (int j = 0; j < letters[i].length; j++) {
                if (word.charAt(k) == letters[i][j]) {
                    k++;
                } 
                else {
                    k = 0;
                }
                if (k == word.length()) {
                    for (int col = j - k + 1; col <= j; col++) {
                        gb.highlight(i, col);
                    }

                    return true;
                }
            }
        }

        return false;
    }

    private boolean searchIterativeWest(String word) {

            String reversedWord = "";
            for (int i = word.length() - 1; i != -1; i--)
            {
                reversedWord += word.charAt(i);
            }

            int k = 0;

            for (int i = 0; i < letters.length; i++) 
            {
                for (int j = 0; j < letters[i].length; j++) {
                    if (reversedWord.charAt(k) == letters[i][j]) {
                        k++;
                    } 
                    else {
                        k = 0;
                    }
                    if (k == reversedWord.length()) {
                        for (int col = j - k + 1; col <= j; col++) {
                            gb.highlight(i, col);
                        }

                        return true;
                    }
                }
            }

            return false;

    }

    private boolean searchIterativeSouth(String word) {
        int k = 0;
        int store = letters[0].length;

        for (int j = 0; j < letters[store].length; j++)
        {
            for (int i = 0; i < letters.length; i++)
            {
                if (word.charAt(k) == letters[i][j])
                {
                    k++;
                }
                else
                {
                    k = 0;
                }
                if (k == word.length())
                {
                    for(int row = i-k+1 ; row <= i; row++)
                    {
                        gb.highlight(row, j);
                    }
                    return true;
                }
            }
        }

        return false;
    }

    private boolean searchIterativeNorth(String word) {

        String reversedWord = "";
        for (int i = word.length() - 1; i != -1; i--)
        {
            reversedWord += word.charAt(i);
        }

        int k = 0;
        int store = 0;

        for(int i = 0; i < letters.length; i++)
        {
            store = letters[i].length;
        }

        for (int j = 0; j < letters[store].length; j++)
        {
            for (int i = 0; i < letters.length; i++)
            {
                if (reversedWord.charAt(k) == letters[i][j])
                {
                    k++;
                }
                else
                {
                    k = 0;
                }
                if (k == reversedWord.length())
                {
                    for(int row = i-k+1 ; row <= i; row++)
                    {
                        gb.highlight(row, j);
                    }
                    return true;
                }
            }
        }

        return false;
    }

第一个文件（Animals.txt）的游戏板看起来像：5X4的二维数组。

X C A T
P A L Q
I R B U
G P X N
G O D W

输出突出 CARP。

第二个文件（Places.txt）的游戏板看起来像：11x15 二维数组

O M J G D A X V C S Q N K I F 
D A X V T Q O M J H A A H F C 
A Y W U R P N L F E I T A L Y
J N H N E T H E R L A N D S F 
D B I Z X V T O A R Q O A Y K 
M K I A H F K R N O D B N N I
N Z Y W P H T V C G C T A A N 
R A Q O T S N L E K K I C M G 
I H P U U F D C A Z D O X R D 
X W O A L E U Z E N E V N E O 
V S U S J R Q L I Z A R B G M 

- Wes Johnson

---

什么是letters？它是一个n x n矩阵吗？还是只是一个数组的数组？ - Rohit Jain

好的，这里有一个提示。你的外层循环应该遍历列，内层循环应该遍历行。这只是与通常遍历数组的方式相反。所以，尝试将 letters[i][j] 更改为 letters[j][i]。我相信你会得到一个异常。你需要解决这个异常。 - Rohit Jain

好的，我会试着调整一下看看能否让它工作，谢谢！ - Wes Johnson

我已经更新了原始帖子，包括堆栈跟踪和完整代码。我正在处理的特定方法是searchIterativeSouth方法。 - Wes Johnson

在外部循环条件中将 letters[store].length 更改为 store。 - Rohit Jain

Answer 1

for (int j = 0; j < letters[i].length; j++)

代替

for (int j = 0; j < letters.length; j++)

- Achintya Jha

---

修复了ArrayIndexOutOfBoundsException错误，我已经玩弄代码很久了，导致出现了这个错误。 - Wes Johnson

@Achintya。仅仅这样做并不能解决问题。问题中还有更多的东西需要处理，而不仅仅是改变循环条件。但是，我希望OP能够找出其中的问题所在。 - Rohit Jain

Answer 2

返回语句应放在for循环外面，否则只会突出显示第一个字母。

...
for (int row = j-k+1; row <=i; row++ )
    {
        //gb.highlight() just calls a method that    highlights the letters.
        gb.highlight(row, j);
        //return true;
    }
return true;
...

- Denis