递归问题——Java

好的，我有一个递归问题，它在大容量时会导致堆栈溢出错误。我增加了堆的大小，以使它在小容量时可以正常工作。问题是在2d阵列中找到最大的连续细胞群，其中包含1个或多个成虫

public class Field {
    Cell[][] cells;
    public Field(Cell[][] cells){
        this.cells=cells;
    }
    /**
     * Sort by what's connected--> recursive helper (rec)
     * @return rank value of 
     */
    int findCore(){
        //Reset ranks
        for(int i=0; i<cells.length; i++)
            for(int j=0; j<cells[0].length; j++)
                cells[i][j].setRank(-1);

        int counter = 0;
        for(int i=0; i<cells.length; i++){
            for(int j=0; j<cells[0].length; j++){
                if(cells[i][j].getRank()==-1 && cells[i][j].getNAdults()>0){
                    rec(i,j, counter);
                    counter++;              
                }
            }
        }
        return findLargest(counter);
    }
    /**
     * Recursive function helper, Gives every group a unique id
     * @param x
     * @param y
     * @param col
     * @return
     */
    void rec(int x, int y, int col){
        if(cells[x][y].getRank()==-1){
            cells[x][y].setRank(col);
            for(int i=-1; i<=1; ++i)
                for(int j=-1; j<=1; ++j)
                    if((x+i)>=0 && (y+j)>=0  && (x+i) < (cells.length) && (y+j)< (cells[0].length))
                        if(cells[x+i][y+j].getNAdults() > 0 && cells[x+i][y+j].getRank() == -1){
                            rec(x+i, y+j, col);
                            break;
                        }
        }
    }
    /**
     * Take all the groups in the field and figure out which one is the largest
     * @param numGroups
     * @return (groupid)
     */
    int findLargest(int numGroups){
        int[] numArray = new int[numGroups];
        for(int i=0; i<cells.length; i++)
            for(int j=0; j<cells[0].length; j++)
                if(cells[i][j].getRank()!=-1)
                    numArray[cells[i][j].getRank()]++;

        int max=0;
        for(int i=0; i<numArray.length; i++)
            if(numArray[i]>numArray[max])
                max=i;

        return max;
    }
    //Test Field functions
    public static void main(String[] args){
        int xSize = 1000;
        int ySize = 1000;
        Field fd = new Field(new Cell[xSize][ySize]);
        for(int i=0; i<xSize; ++i){
            for(int j=0; j<ySize; ++j)
                //if(i==0 || i ==3 || i==1)
                    fd.cells[i][j] = new Cell(1,1,1);
                //else
                    //fd.cells[i][j] = new Cell();
        }
        System.out.println("Largest Group: "  + fd.findCore());
        for(int i=0; i<xSize; ++i){
            for(int j=0; j<ySize; ++j){
                System.out.print(fd.cells[i][j].getRank() + "\t");
            }
            System.out.print("\n");
        }

    }
}

公共类字段{
细胞[][]细胞；
公共字段（单元格[][]单元格）{
这个。细胞=细胞；
}
/**
*按连接内容排序-->递归帮助器（rec）
*@返回等级值
*/
int findCore（）{
//重新排列
对于（int i＝0；i）如果得到STACKOFFROW流错误，则递归深度可能太大。如果可能的话，考虑迭代方法。

也可以增加堆栈的大小，而不是JVM的堆大小。为此，将-XSS参数设置为JVM。例如，-XSS2048 K.
> P>如果获得STACKOFFROW流错误，那么递归深度可能太大。如果可能的话，请考虑迭代方法。

您还可以增加JVM的堆栈大小，而不是堆大小。为此，请将-Xss参数设置为JVM。例如，-Xss2048k。
这里的主要问题是，由于许多基于堆栈的内存系统的性质，每次调用都会为该方法调用创建一个新堆栈，并且没有需要的后端递归优化ans表示每个递归调用都会创建一个新堆栈。您最好的选择可能是将等式更改为循环，而不是递归。
这里的主要问题是，由于许多基于堆栈的内存系统的性质，每个调用都会为该方法调用创建一个新堆栈，并且没有尾部递归优化，这意味着每个递归调用都会创建一个新的堆栈。最好的办法是将方程改为循环，而不是递归。
您可以“手动”实现递归通过使用堆栈。在每一步中，您都会推动当前状态，然后在展开时再次弹出它。如果您使用自己的堆栈而不是调用堆栈，它可能会更大，并且不会出现堆栈溢出异常

例如，如果您想避免使用太多内存，可以使用Wikipedia上列出的众多内存之一。
您可以“手动”实现递归通过使用堆栈。在每一步中，您都会推动当前状态，然后在展开时再次弹出它。如果您使用自己的堆栈而不是调用堆栈，它可能会更大，并且不会出现堆栈溢出异常

例如，如果您想避免使用太多内存，可以使用Wikipedia上列出的众多内存中的一个。
请正确格式化您的代码对不起，函数
findLargest
在哪里？我看不到它。如果出现堆栈溢出错误，是什么让您认为您没有耗尽内存？java没有尾部递归，请检查卡拉：-）抱歉，一个缩进空间根本不够。代码几乎看不清。请正确设置代码格式抱歉，函数
findLargest
在哪里？我看不到它。如果出现堆栈溢出错误，是什么让你认为没有耗尽内存？java没有尾部递归，请检查scala:-）抱歉，一个缩进空间光有牙齿是不够的。代码几乎看不清。我认为他的问题的根源是一个糟糕的算法。我认为他的问题的根源是一个糟糕的算法。