如何遍历java中搜索单词的2d字符数组？

我在学校作业上遇到了麻烦，希望能有一些见解。我被要求使用25x25 2d字符数组创建一个wordsearch，并通过开发一种算法来搜索该数组，从而找到21个预定义的单词

到目前为止，我已经能够创建一个需要查找的单词的不规则数组，以及在每个位置放置字符的2d数组

in = new ASCIIDataFile("wordsearch.txt");
display = new ASCIIDisplayer();
int numberWords = in.readInt();

wordlist = new char[numberWords][];

for (int i =0; i<wordlist.length; i++){
  wordlist[i] = in.readLine().toUpperCase().toCharArray(); 
}
for(int i = 0;i<wordlist.length; i++){
  display.writeLine(" ");
  for(int j = 0;j<wordlist[i].length; j++){
    display.writeChar(wordlist[i][j]);
  }
}
//done wordlists

int gridLength = in.readInt();
int gridHeight = in.readInt();

grid = new char[gridHeight][gridLength];

for(int i = 0;i<gridLength; i++){
  grid[i] = in.readLine().toCharArray();

}

in=new-ASCIIDataFile（“wordsearch.txt”）；
display=新的ASCIIDisplayer（）；
int numberWords=in.readInt（）；
wordlist=新字符[numberWords][]；
对于（int i＝0；i技巧，你不需要单独考虑所有8个可能的方向。你可以用向量来表示每一个。例如，‘前进’方向将是<代码>（0, 1）< /代码>（第一行数，然后是列）-指向右边的向量。对角线左上方向将是<代码>（-1，-1）< /代码>。
然后，创建一个函数

boolean findWord(int row, int col, int d_row, int d_col, char[] word);

它可以获取当前矩阵位置（
（行，列）
，单词应该从哪里开始）、搜索方向（
（行，列）
）和要查找的单词。它返回给定单词是否在这里。

然后您可以为不同的方向调用它，例如

findWord(row, col, -1, 0, word);
findWord(row, col, -1, 1, word);
findWord(row, col, 0, 1, word);
...

（我按时钟顺序列出它们）

实现
findWord
只是将当前位置增加
d_row
和
d_col
，直到我们发现字符或单词结尾不匹配。基本例程如下

while (row < total_rows && row >= 0 && col < total_columns && col >= 0) {
    // check character here
    ...
    row += d_row;
    col += d_col;
}

while（行=0&&col=0）{
//在这里检查字符
...
行+=d_行；
col+=d_col；
}

我敢打赌，您将拥有40行的所有处理代码（输入读取除外）。
您首先需要了解如何在较大的字符串中搜索短字符串。这里有两个选项：从最简单的算法到更复杂的算法（如Knuth Morris Pratt及其家族）。您可以在此处获取其描述的列表：。我强烈建议您先尝试简单搜索

一旦您可以在另一个字符串中搜索一个字符串，您将需要抽象访问较大字符串的方式，并使矩阵数据适应它

基本上假设这个矩阵：

   1 2 3 4 
   -------
1| a b c d 
2| b c d a
3| c d a b
4| d a b c

这根绳子是abc的

您将首先制作一些代码，以便能够在
abc
中找到
abc
或
bcda
或
cdab
等

一旦你能做到这一点，你应该建立提取（对于每种可能的查找类型：水平、垂直、对角线、反向对角线）字符序列的中间步骤，并对它们应用前面的算法

例如，如果我们想要对角搜索，我们将从矩阵中生成7个字符串：

a
bb
ccc
dddd
aaa
bb
c

如果要水平搜索，将生成以下字符串：

abcd
bcda
cdab
dabc

在每根绳子里搜索

一旦这项工作开始，您应该将搜索与从矩阵中读取适当的字符结合起来。希望如果您遵循此路径，您将能够找到答案：）

祝你好运。
要在任意尺寸的2D矩阵中沿对角线移动，希望下面的函数能有所帮助

public static void prinDiagonalsInGrid(char[][] grid, int rows, int cols)
{
    String result = "";
    int min = Math.min(rows, cols);
    int max = Math.max(rows, cols);

    int sameLengthDiagonals = max - min + 1;
    int totalDiagonals = (rows + cols) - 1;

    for (int p = 0; p < totalDiagonals; p++)
    {
        int xIndex;
        int maxCnt;

        if (p < (min - 1)) // First diagonals
        {
            maxCnt = xIndex = p;
        }
        // diagonals of equal length in the middle
        else if (sameLengthDiagonals != 0 &&
                 p >= (min - 1) && p < (sameLengthDiagonals + min - 1))
        {
            if (rows < cols)
                xIndex = rows - 1;
            else
                xIndex = p;
            maxCnt = min - 1;
        }
        else  // Last diagonals
        {
            xIndex = rows - 1;
            maxCnt = totalDiagonals - p - 1;
        }

        for (int cnt = 0; cnt <= maxCnt; cnt++)
        {
            result += grid[xIndex][p - xIndex] + "    ";
            --xIndex;
        }
        result += "\n";
    }
    System.out.println(result);
}

publicstaticvoidprindiagonalsingrid（char[][]网格，int行，int列）
{
字符串结果=”；
int min=Math.min（行、列）；
int max=Math.max（行、列）；
int SameleLength对角线=最大值-最小值+1；
整数总对角线=（行+列）-1；
对于（int p=0；p=（最小值-1）和&p<（等长对角线+最小值-1））
{
如果（行<列）
xIndex=行-1；
其他的
xIndex=p；
maxCnt=min-1；
}
else//最后一条对角线
{
xIndex=行-1；
maxCnt=总对角线-p-1；
}
对于（int cnt=0；25个字符字符串的cnt KMP有点太多：）更不用说，OP在实现比这更简单的东西时遇到了麻烦。@Nikita-true。。我的坏消息是，我确实被它迷住了：（.我确实提到有很多更简单的算法，我认为OP实际上能够研究它们。在KMP的维基百科页面上还有一个指向更简单算法的链接：）.你在课堂上看过树了吗？或者你应该从上节课就知道它们吗？不，我没有学过树，我不应该用我不知道的东西。
public static void prinDiagonalsInGrid(char[][] grid, int rows, int cols)
{
    String result = "";
    int min = Math.min(rows, cols);
    int max = Math.max(rows, cols);

    int sameLengthDiagonals = max - min + 1;
    int totalDiagonals = (rows + cols) - 1;

    for (int p = 0; p < totalDiagonals; p++)
    {
        int xIndex;
        int maxCnt;

        if (p < (min - 1)) // First diagonals
        {
            maxCnt = xIndex = p;
        }
        // diagonals of equal length in the middle
        else if (sameLengthDiagonals != 0 &&
                 p >= (min - 1) && p < (sameLengthDiagonals + min - 1))
        {
            if (rows < cols)
                xIndex = rows - 1;
            else
                xIndex = p;
            maxCnt = min - 1;
        }
        else  // Last diagonals
        {
            xIndex = rows - 1;
            maxCnt = totalDiagonals - p - 1;
        }

        for (int cnt = 0; cnt <= maxCnt; cnt++)
        {
            result += grid[xIndex][p - xIndex] + "    ";
            --xIndex;
        }
        result += "\n";
    }
    System.out.println(result);
}