递归 StackOverflow 异常答案

【问题标题】：Recursive StackOverflow Exception递归 StackOverflow 异常
【发布时间】：2018-01-03 09:00:07
【问题描述】：

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

【问题讨论】：

你试过增加java分配的内存吗？如果您的代码正在处理小型 suduko 谜题但不是大型谜题，那么问题只是递归算法需要使用大量内存并且 java 快用完了。
我不知道该怎么做，所以我没有尝试过。你能告诉我该怎么做吗？这是在 Visual Studio C# 中制作的
哦，你用的是c#，去google“如何增加visual studio c#分配的内存”
还有其他解决方案吗？
其他解决方案是不要使用递归，或者您需要找到更有效的递归算法。

标签： c# recursion stack-overflow

【解决方案1】：

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

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

当一个函数以递归方式调用自身时，每次调用自身时都会有更多的数据被放入堆栈，一遍又一遍，直到其中一个结束时才会将它们从堆栈中取出。

你的问题是这样会很快把栈填满，当你用完栈空间时，程序就会崩溃。递归函数对某些事情很有用，但前提是它们不需要递归太多次。

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

【讨论】：