在C语言中搜索二维数组中的子字符串

这是用于在2d数组中搜索子字符串的内容

int left_to_rigth(char matrix[ROW][COLUNM], char str1[])
{
    int i = 0, j, counting = 0, wordcnt;
    int length = computeLength(str1);   //returns legth of string   
    int index = -1;

    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COLUNM; j += 1)
        {
            if (matrix[i][j] == str1[0])
            {
                for (wordcnt = 0; wordcnt < length; wordcnt++)
                {
                    if (matrix[i][j + wordcnt] == str1[wordcnt])
                    {
                        counting++;
                    }
                }

                if (counting == length)
                {
                    index = (i *12) + j;
                }
            }
        }
    }

    return index;
}

所以函数返回SHOUT的起始点是12，但是当我尝试搜索单词KEREM时，它应该给我110，但是它返回-1，表示单词不存在。 似乎每次输入后，代码只搜索前3行，返回-1。你能帮我一下吗？我是初学者

---

这只是我需要做的第一部分，这样它可以在各个方向搜索我可以编写4个单独的函数，如果它们不返回-1，则调用它们，但我需要首先让它工作好，我已经做了一些加速和简化

不需要单独的

计数

[至少对于从左到右和从右到左]因为您可以使用

wordidx

此外，一旦在内部循环中找到匹配项，就不需要继续进行。而且，您可以提前停止外部循环

计算调用外部的

str1

的长度并将

length

作为参数传递会更快。另外，

strlen

应该可以正常工作

在从左到右的方向上，

j

无需一直到

列-1

，因为如果矩阵行上没有足够的空间来完成剩余的字符串长度，则最后N个插槽无法匹配

而且，这是未定义的行为，因为您将溢出到下一行。这将是无害的[但结果是错误的]，除了最后一行，您将超出整个矩阵的末尾

因此，我添加了

jmax

值

COLUMN-length

从右到左略显复杂。

jmax

技巧至关重要

下面是两个函数[它们编译得很干净，但我没有测试它们]：

#include <string.h>

#define ROW     10
#define COLUMN  10

int
left_to_right(char matrix[ROW][COLUMN], const char *str1, int length)
{
    char *matcur;
    int i;
    int j;
    int wordidx;

    int jmax = COLUMN - length;

    int index = -1;

    jmax += 1;
    for (i = 0;  i < ROW;  ++i) {
        for (j = 0;  j < jmax;  ++j, ++matcur) {
            matcur = &matrix[i][0];

            if (matcur[0] != str1[0])
                continue;

            for (wordidx = 1;  wordidx < length;  ++wordidx) {
                if (matcur[wordidx] != str1[wordidx])
                    break;
            }

            if (wordidx == length) {
                index = (i * COLUMN) + j;
                break;
            }
        }

        if (index >= 0)
            break;
    }

    return index;
}

int
right_to_left(char matrix[ROW][COLUMN], const char *str1, int length)
{
    const char *matcur;
    int i;
    int j;
    int wordidx;

    int jmax = COLUMN - length;

    int index = -1;

    for (i = 0;  i < ROW;  ++i) {
        matcur = &matrix[i][jmax];

        for (j = jmax;  j >= 0;  --j, --matcur) {
            if (matcur[0] != str1[0])
                continue;

            for (wordidx = 0;  wordidx < length;  ++wordidx) {
                if (matcur[wordidx] != str1[wordidx])
                    break;
            }

            if (wordidx == length) {
                index = (i * COLUMN) + j;
                break;
            }
        }

        if (index >= 0)
            break;
    }

    return index;
}

#包括
#定义第10行
#定义第10列
int
从左到右（字符矩阵[行][列]，常量字符*str1，整数长度）
{
char*matcur；
int i；
int j；
int-wordidx；
int jmax=列-长度；
int指数=-1；
jmax+=1；
对于（i=0；i=0）
打破
}
收益指数；
}
int
从右到左（字符矩阵[行][列]，常量字符*str1，整数长度）
{
const char*matcur；
int i；
int j；
int-wordidx；
int jmax=列-长度；
int指数=-1；
对于（i=0；i=0；--j，--matcur）{
if（matcur[0]！=str1[0]）
继续；
for（wordidx=0；wordidx=0）
打破
}
收益指数；
}

您需要在循环中的某个位置重置计数。在第6点（a'K'）

计数变为
1
；在第35点，它变为
2
。每个pmg，插入
counting=0
就在
for（wordcnt=0；…）
omg这是个错误：（（（（（（（（（（（（（（（（（（（（（（（（（（（（（）））非常感谢，所以如果我想让它从右向左搜索，我只需将`if（matrix[I][j+wordcnt]==str1[wordcnt]）`更改为`if（matrix[I][j-wordcnt]==str1[wordcnt]）`I对吗@CraigEstey@pmg
#include <string.h>

#define ROW     10
#define COLUMN  10

int
left_to_right(char matrix[ROW][COLUMN], const char *str1, int length)
{
    char *matcur;
    int i;
    int j;
    int wordidx;

    int jmax = COLUMN - length;

    int index = -1;

    jmax += 1;
    for (i = 0;  i < ROW;  ++i) {
        for (j = 0;  j < jmax;  ++j, ++matcur) {
            matcur = &matrix[i][0];

            if (matcur[0] != str1[0])
                continue;

            for (wordidx = 1;  wordidx < length;  ++wordidx) {
                if (matcur[wordidx] != str1[wordidx])
                    break;
            }

            if (wordidx == length) {
                index = (i * COLUMN) + j;
                break;
            }
        }

        if (index >= 0)
            break;
    }

    return index;
}

int
right_to_left(char matrix[ROW][COLUMN], const char *str1, int length)
{
    const char *matcur;
    int i;
    int j;
    int wordidx;

    int jmax = COLUMN - length;

    int index = -1;

    for (i = 0;  i < ROW;  ++i) {
        matcur = &matrix[i][jmax];

        for (j = jmax;  j >= 0;  --j, --matcur) {
            if (matcur[0] != str1[0])
                continue;

            for (wordidx = 0;  wordidx < length;  ++wordidx) {
                if (matcur[wordidx] != str1[wordidx])
                    break;
            }

            if (wordidx == length) {
                index = (i * COLUMN) + j;
                break;
            }
        }

        if (index >= 0)
            break;
    }

    return index;
}