在 Java 中检查二维数组中的邻居的更有效方法

Question

大家好，对于我的一些大学作业，我发现需要检查二维数组（网格）中的相邻单元格。我使用的解决方案有点像使用异常进行黑客攻击，我正在寻找一种方法来清理它，而无需像我的一些同学那样使用大量 if 语句。我当前的解决方案是，

for ( int row = 0; row < grid.length; row++ ) {
    for ( int col = 0; col < grid.length; col++ ) {
        // this section will usually be in a function
        // checks neighbours of the current "cell"
        try {
            for ( int rowMod = -1; rowMod <= 1; rowMod++ ) {
                for ( int colMod = -1; colMod <= 1; colMod++ ) {
                    if ( someVar == grid[row+rowMod][col+colMod] ) {
                        // do something
                    }
                }
            }
        } catch ( ArrayIndexOutOfBoundsException e ) {
            // do nothing, continue
        }
        // end checking neighbours
    }
}

一想到使用异常使代码正常工作的效率低下，我就感到不寒而栗，因此我正在寻找有关如何消除代码中对异常的依赖而不牺牲可读性（如果可能的话）的建议，并且只是我怎样才能使这个代码段更加高效。提前致谢。

Answer 1

你可以试试这个。
首先决定网格的大小 假设它是 8 X 8 &分配 MIN_X = 0, MIN_Y = 0, MAX_X =7, MAX_Y =7

你当前的位置由 thisPosX , thisPosY 表示，然后尝试这个：

int startPosX = (thisPosX - 1 < MIN_X) ? thisPosX : thisPosX-1;
int startPosY = (thisPosY - 1 < MIN_Y) ? thisPosY : thisPosY-1;
int endPosX =   (thisPosX + 1 > MAX_X) ? thisPosX : thisPosX+1;
int endPosY =   (thisPosY + 1 > MAX_Y) ? thisPosY : thisPosY+1;


// See how many are alive
for (int rowNum=startPosX; rowNum<=endPosX; rowNum++) {
    for (int colNum=startPosY; colNum<=endPosY; colNum++) {
        // All the neighbors will be grid[rowNum][colNum]
    }
}

你可以在 2 个循环中完成它。

Answer 2

因此，row 和 col 当前包含我要检查其邻居的单元格的坐标。因此，如果我有一个名为 START_OF_GRID 的类变量，其中包含 0，我的解决方案将如下：

int rowStart  = Math.max( row - 1, START_OF_GRID   );
int rowFinish = Math.min( row + 1, grid.length - 1 );
int colStart  = Math.max( col - 1, START_OF_GRID   );
int colFinish = Math.min( col + 1, grid.length - 1 );

for ( int curRow = rowStart; curRow <= rowFinish; curRow++ ) {
    for ( int curCol = colStart; curCol <= colFinish; curCol++ ) {
        // do something
    }
}

Answer 3

为什么不能在数组访问之前检查 row+rowMod 和 col+colMod 的有效性？

类似于：

 r=row+rowMod;
 c=col+colMod;
 if (r < 0 || c < 0 || r >= grid.length || c >= grid.length) continue;

或者（不继续）：

 if (r >= 0 && c >= 0 && r < grid.length && c < grid.length && 
     someVar == grid[r][c]) { /* do something */ }

Answer 4

基本原则是不要访问越界的东西——所以要么保护界限，要么从一开始就不要越界。也就是说，从不会立即出界的地方开始，在出界之前停止。

for ( int row = 1; row < grid.length - 1; row++ ) {
    for ( int col = 1; col < grid.length - 1; col++ ) {
        // this section will usually be in a function
        // checks neighbours of the current "cell"
        for ( int rowMod = -1; rowMod <= 1; rowMod++ ) {
            for ( int colMod = -1; colMod <= 1; colMod++ ) {
                if ( someVar == grid[row+rowMod][col+colMod] ) {
                    // do something
                }
            }
        }
        // end checking neighbours
    }
}

与您当前的代码一样，这不一定能够正确处理边缘条件 - 也就是说，它在 3x3 网格适合矩阵的任何地方应用 3x3 网格，但在以下情况下不会将网格缩小为 2x2、2x3 或 3x2 网格：在矩阵的边缘。然而，它将允许主体中的方法检查 3x3 网格来观察矩阵中的每个单元。

Answer 5

如果我正确理解你的代码，并且正确地猜测你的担忧，那么当感兴趣的单元格位于网格的一个边缘时，你会试图避免检查不存在的邻居。一种方法（可能适合也可能不适合您的应用程序）是在网格周围放置一个 1 单元格宽的边框。然后，您可以在这个扩展网格的内部运行循环，并且您检查的所有单元格都有 4 个邻居（如果计算对角相邻单元格，则为 8 个）。

Answer 6

这个怎么样：

private static void printNeighbours(int row, int col, int[][] Data, int rowLen, int colLen)
{
    for(int nextR=row-1; nextR<=row+1; nextR++)
    {
        if(nextR<0 || nextR>=rowLen)
            continue;  //row out of bound
        for(int nextC=col-1; nextC<=col+1; nextC++)
        {
            if(nextC<0 || nextC>=colLen)
                continue;  //col out of bound
            if(nextR==row && nextC==col)
                continue;    //current cell
            System.out.println(Data[nextR][nextC]);
        }
    }
}

Answer 7

private void fun(char[][] mat, int i, int j){
    int[] ith = { 0, 1, 1, -1, 0, -1 ,-1, 1};
    int[] jth = { 1, 0, 1, 0, -1, -1 ,1,-1};
     // All neighbours of cell
     for (int k = 0; k < 8; k++) {
            if (isValid(i + ith[k], j + jth[k], mat.length)) {
                //do something here 
            }
        }
}

private boolean isValid(int i, int j, int l) {
        if (i < 0 || j < 0 || i >= l || j >= l)
            return false;
        return true;
}