C# 递归堆栈溢出异常

我试图做一个数独解算程序，我有一个StackOverflow异常问题。我不知道该怎么做才能解决这个问题，因为这个算法很好，如果只有几个递归函数，它就可以工作。我试图用try-catch解决这个问题，但我不是很擅长。下面是代码，如何使其正常工作而不出现StackOverflow错误

public static int Rezolva_sudoku(int i,int j,int[,] cells, int[,] cells2)
    {
        try
        {

            int ok = 0;
            int val;
            if (j == 10)
            {
                j = 1;
                i++;
            }
            if (i == 10)
            {
                for (int m = 1; m <= 9; m++)
                    for (int p = 1; p <= 9; p++)
                        if (cells[m, p] != 0)
                            ok = 1;
                if (ok == 1)
                    return 1;
                else
                    return 0;
            }

            if ((cells[i, j] == cells2[i, j]) && back == 0)
                if (j == 1)
                    return Rezolva_sudoku(i - 1, 9, cells, cells2);
                else
                    return Rezolva_sudoku(i, j - 1, cells, cells2);
            if (i != 10)
            {
                back = 1;
                if (cells[i, j] == cells2[i, j] && back == 1)
                    return Rezolva_sudoku(i, j + 1, cells, cells2);
                for (val = cells[i, j] + 1; val <= 9; val++)
                {
                    if (legal(i, j, val, cells))
                    {

                        cells[i, j] = val;
                        return Rezolva_sudoku(i, j + 1, cells, cells2);

                    }


                }
            }
            if (i != 10)
            {
                if (j == 1)
                {
                    back = 0;
                    cells[i, j] = 0;
                    return Rezolva_sudoku(i - 1, 9, cells, cells2);
                }
                else
                {
                    if (cells[i, j - 1] == cells2[i, j - 1])
                    {
                        if (j == 2)
                        {
                            if (cells[i - 1, 9] == cells2[i - 1, 9])
                            {
                                back = 0;
                                cells[i, j] = 0;
                                return Rezolva_sudoku(i - 1, 8, cells, cells2);
                            }
                            else
                            {
                                back = 0;
                                cells[i, j] = 0;
                                return Rezolva_sudoku(i - 1, 9, cells, cells2);
                            }
                        }
                        else
                        {
                            back = 0;
                            cells[i, j] = 0;
                            return Rezolva_sudoku(i, j - 2, cells, cells2);
                        }
                    }
                    back = 0;
                    cells[i, j] = 0;
                    return Rezolva_sudoku(i, j - 1, cells, cells2);

                }


            }

        }
        catch (StackOverflowException e)
        {
            MessageBox.Show(e.ToString());
        }
        return 0;
    }

public static int Rezolva_数独（int i，int j，int[，]单元格，int[，]单元格2）
{
尝试
{
int ok=0；
int-val；
如果（j==10）
{
j=1；
i++；
}
如果（i==10）
{
对于（int m=1；m，问题是堆栈空间不足

每次调用函数时，都会将一些数据放在堆栈上，当函数结束时，这些数据会再次被删除

当一个函数递归地调用自身时，每次调用自身时，都会有更多的数据放在堆栈上，并且在其中一个结束之前，这些数据都不会从堆栈中取出

你的问题是，这会很快填满堆栈，当堆栈空间用完时，程序会崩溃。递归函数在某些方面很有用，但前提是它们不需要重复太多次

现在有好消息和坏消息：好消息是这是可以修复的，但坏消息是修复它的最好方法是完全重写您的程序，这样它就可以使用循环而不是递归函数来工作。
您是否尝试过增加java的分配内存？如果您的代码正在处理小的suduko难题，而不是大的难题，请不要当问题只是递归算法需要使用大量内存，而java正在耗尽时。我不知道怎么做，这就是为什么我没有尝试。你能告诉我怎么做吗？这是在Visual Studio C中制作的。哦，你在使用C，我们去谷歌“如何增加Visual Studio C分配的内存”还有其他的解决方案吗？其他的解决方案是不要使用递归，或者你需要找到一个更有效的递归算法。