遍历数组的边缘成员时数组索引越界

Question

我正在 Java 使用递归回溯算法创建一个随机迷宫生成器。我需要将迷宫单元格数据数组的边缘设置为已经被算法访问过，这样它就不会越界。问题可能就在我面前，我就是看不出我的错误在哪里。

这是整个错误消息：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 30
    at mazeMaker.Maze.initBoundries(Maze.java:55)
    at mazeMaker.Maze.<init>(Maze.java:46)
    at mazeMaker.Main.main(Main.java:8)

我已尽我所能尝试跟踪错误并尝试更改我的变量。该程序依赖于多个 class 文件，所以我认为最好只显示整个内容。

Main.java

package mazeMaker;

public class Main 
{

    public static void main(String[] args) 
    {
        Maze mainMaze = new Maze(20, 30);
    }

}

Maze.java

package mazeMaker;

import java.util.Random;
import java.util.Stack;

public class Maze 
{
    public int xSize = 0;
    public int ySize = 0;
    public int totalDimensions = 0;

    Random randomGenerator = new Random();

    public Cell[][] cellData;

    public Stack<Cell> cellStack = new Stack<Cell>();

    Cell tempCell; // Temporary variable used for maze generation

    public Maze(int xSize, int ySize) 
    {
        cellData = new Cell[xSize][ySize];
        this.xSize = xSize;
        this.ySize = ySize;
        this.totalDimensions = this.xSize * this.ySize;

        // Initialize array objects
        for (int i = 0; i < this.xSize; i++) 
        {
            for (int j = 0; j < this.ySize; j++) 
            {
                cellData[i][j] = new Cell();
            }
        }

        // Assign x and y positions
        for (int i = 0; i < this.xSize; i++) 
        {
            for (int j = 0; j < this.ySize; j++) 
            {
                cellData[i][j].xPos = i;
                cellData[i][j].yPos = j;
            }
        }

        initBoundries();
    }

    private void initBoundries() 
    {
        // Initialize the border cells as visited so we don't go out of bounds      
        for (int col = 0; col < this.xSize; col++)
        {
                cellData[0][col].hasBeenVisited  = true;
                cellData[this.ySize][col].hasBeenVisited = true;
        }

        for (int row = 0; row < this.ySize; row++)
        {
                cellData[row][0].hasBeenVisited =  true;
                cellData[row][this.xSize].hasBeenVisited = true;
        }
    }

    private void generateMaze(int x, int y) 
    {
        // Set current cell as visited
        cellData[x][y].hasBeenVisited = true;

        // While there are unvisited neighbors
        while (!cellData[x][y+1].hasBeenVisited || !cellData[x+1][y].hasBeenVisited || !cellData[x][y-1].hasBeenVisited || !cellData[x-1][y].hasBeenVisited) 
        {
            // Select a random neighbor
            while (true) 
            {
                int r = randomGenerator.nextInt(4);
                if (r == 0 && !cellData[x][y+1].hasBeenVisited) 
                {
                    cellStack.push(cellData[x][y]);
                    cellData[x][y].hasNorthWall = false;
                    cellData[x][y+1].hasSouthWall = false;
                    generateMaze(x, y + 1);
                    break;
                }
                else if (r == 1 && !cellData[x+1][y].hasBeenVisited) 
                {
                    cellStack.push(cellData[x][y]);
                    cellData[x][y].hasEastWall = false;
                    cellData[x+1][y].hasWestWall = false;
                    generateMaze(x+1, y);
                    break;
                }
                else if (r == 2 && !cellData[x][y-1].hasBeenVisited) 
                {
                    cellStack.push(cellData[x][y]);
                    cellData[x][y].hasSouthWall = false;
                    cellData[x][y-1].hasNorthWall = false;
                    generateMaze(x, y-1);
                    break;
                }
                else if (r == 3 && !cellData[x-1][y].hasBeenVisited) 
                {
                    cellStack.push(cellData[x][y]);
                    cellData[x][y].hasWestWall = false;
                    cellData[x-1][y].hasEastWall = false;
                    generateMaze(x-1, y);
                    break;
                }
            }
        }

        // There are no unvisited neighbors
        tempCell = cellStack.pop();
        generateMaze(tempCell.xPos, tempCell.yPos);

    }

    // Begin generating maze at top left corner
    private void generateMaze() 
    {
        generateMaze(1,1);
    }

}

Cell.java

package mazeMaker;

public class Cell 
{
    public boolean isCurrentCell;
    public boolean hasBeenVisited;
    public boolean hasNorthWall;
    public boolean hasSouthWall;
    public boolean hasEastWall;
    public boolean hasWestWall;
    public int xPos;
    public int yPos;
}

Answer 1

我的猜测来自 initBoundries()

中的这段代码

    // Initialize the border cells as visited so we don't go out of bounds      
    for (int col = 0; col < this.xSize; col++)
    {
            cellData[0][col].hasBeenVisited  = true;
            cellData[this.ySize][col].hasBeenVisited = true;
    }

this.ySize 初始化后（从构造函数）具有值 30。

Answer 2

cellData[this.ySize][col].hasBeenVisited = true;

您已将 cellData 初始化为 cellData[20][30]，但在上述行中您正在调用 cellData[30][col]。第一个括号的值应为 0 到 19，而不是 30，因为行大小为 20。

遍历数组的边缘成员时数组索引越界

Array index out of bounds while traversing edge members of array

java

arrays

loops

maze

indexoutofboundsexception