Java 递归数组遍历问题

我有一些stackoverflow问题，希望有人能给我一些关于非递归/非递归解决方案的见解

Ident[][] map = ...

private int explore(Ident item, int xcoord, int ycoord) {
    if ((map[xcoord][ycoord] == null) || !map[xcoord][ycoord].equals(item))
             return 0;

    map[xcoord][ycoord] = null;
    int sumX, sumY, counter = 1;
    item.translate(xcoord, ycoord);

    for (int y = -1; y <= 1; y++)
        for (int x = -1; x <= 1; x++) {
             sumX = x + xcoord;
             sumY = y + ycoord;
            if (((y != 0) || (x != 0)) && (sumX >= 0) && (sumX < map.length) && 
                     (sumY >= 0) && (sumY < map.[0].length))
                     counter += explore(item, sumX, sumY);
             }
        }
    }
    return counter;
}

Ident[]map=。。。
私有int-explore（标识项、int-xcoord、int-ycoord）{
如果（（map[xcoord][ycoord]==null）| |！map[xcoord][ycoord].equals（项））
返回0；
map[xcoord][ycoord]=null；
int sumX，sumY，计数器=1；
翻译（xcoord，ycoord）；
对于（int y=-1；y=0）和&（sumY

该方法提供了一个标识对象的二维数组、一个目标标识和数组中的起始位置。它递归地遍历数组 计算标识占用的连续区域的大小。它还将输入的ID项集中在该区域的中间。 通过在map数组中循环并对任何非null元素调用explore方法，我可以构建一个以区域为中心的Ident项数组，其大小与其区域相关

我们可以看到，除了小贴图之外，任何东西都会导致堆栈溢出

---

有人有其他方法来完成同样的任务吗？或者一些见解来帮助我找到一个？

为了消除递归，创建一个坐标列表，以便在其中包含任何项目时进行探索和循环；在你的循环中，建立一个新的坐标列表进行探索，在循环结束时，用新列表替换旧列表。

这让我回到了80年代中期。任何洪水填充算法都需要一定的状态。不幸的是，我不记得算法了。对于大面积区域有效的方法对于迷宫可能不会有效

为了避免递归，而不是递归，只需将本应调用的数据添加到堆栈中即可。循环从堆栈顶部弹出下一个未探测的坐标。使用堆栈而不是FIFO队列可以稍微改善局部性，尽管这可能不会产生很大的影响

private int explore(Ident item, int xcoord, int ycoord) {
    int counter = 0;

    Queue<Point> stack = Collections.asLifoQueue(new ArrayDeque<Point>());
    stack.add(new Point(xcoord, ycoord));

    while (!stack.isEmpty()) {
        Point point = stack.remove();
        xcoord = point.x;
        ycoord = point.y;

        if (!item.equals(map[xcoord][ycoord])) {
            continue;
        }

        ++counter;
        map[xcoord][ycoord] = null;
        item.translate(xcoord, ycoord);

        for (int y = -1; y <= 1; y++)
            for (int x = -1; x <= 1; x++) {
                 int sumX = x + xcoord;
                 int sumY = y + ycoord;
                 if (
                     !(x == 0 && y == 0) &&
                     0 <= sumX && sumX < map.length &&
                     0 <= sumY && sumY < map[0].length
                 ) {
                     stack.add(new Point(sumX, sumY));
                 }
            }
        }
    }
    return counter;
}

private int explore（标识项、int xcoord、int ycoord）{
int计数器=0；
队列堆栈=Collections.asLifoQueue（新的ArrayDeque（））；
添加（新点（xcoord，ycoord））；
而（！stack.isEmpty（））{
Point=stack.remove（）；
xcoord=点x；
ycoord=点y；
如果（！item.equals（map[xcoord][ycoord]））{
继续；
}
++计数器；
map[xcoord][ycoord]=null；
翻译（xcoord，ycoord）；
对于（int y=-1；y）Oops。错过了。谢谢。将答案缩减到相关部分。它足够接近了，非常感谢您花时间做这件事。