Question

我试图做一个数独求解器程序，我遇到了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;
    }

Answer 1

问题是你的堆栈空间不足。

每次调用一个函数时，一些数据都会被放入堆栈中，并在函数结束时再次被取消。

当一个函数以递归方式调用自身时，每次调用自身时，会有更多的数据被放到堆栈中，反复执行，并且没有一个数据从堆栈中取出，直到其中一个数据结束。

您的问题是，这可以快速填满堆栈，当您的堆栈空间不足时，程序将崩溃。递归函数对某些事情很有用，但前提是它们不需要重复太多次。

现在有好消息和坏消息：好消息是这可以解决，但坏消息是修复它的最好方法是完全重写你的程序，以便它使用循环而不是使用递归函数来完成它的工作

递归StackOverflow异常

1 个答案: