java - 在这种情况下，我应该尝试修复特殊情况还是只捕获 stackoverflow 错误？

Question

public boolean isConnected(int row, int col) {    //helper Method 
        int i;
        int j;

        if (BOARD[row][col].isEmpty())
            return false;
        for (i = row; i > 0; i--)
            if (hasRed(i, col))
                return true;
            else if (isEmpty(i, col))
                break;
        for (i = row; i < ROWS; i++)
            if (hasRed(i, col))
                return true;
            else if (isEmpty(i, col))
                break;
        for (i = col; i < COLS; i++)
            if (hasRed(row, i))
                return true;
            else if (isEmpty(row, i))
                break;
        for (i = col; i > 0; i--)
            if (hasRed(row, i))
                return true;
            else if (isEmpty(row, i))
                break;
        for (i = row, j = col; i > 0 && j < COLS; i--, j++)
            if (hasRed(i, j))
                return true;
            else if (isEmpty(i, j))
                break;
        for (i = row, j = col; i < ROWS && j > 0; i++, j--)
            if (hasRed(i, j))
                return true;
            else if (isEmpty(i, j))
                break;
        for (i = row, j = col; i > 0 && j > 0; i--, j--)
            if (hasRed(i, j))
                return true;
            else if (isEmpty(i, j))
                break;
        for (i = row, j = col; i < ROWS && j < COLS; i++, j++)
            if (hasRed(i, j))
                return true;
            else if (isEmpty(i, j))
                break;

        return false;

    }    

//可能导致异常的主要方法在尝试了许多测试用例之后算法总是终止，如果有一个真正的解决方案，但可能会或可能不会终止错误的解决方案，我猜的原因是递归步骤没有简化原来的问题，但实际上扩大了它!为了有机会获得正确的解决方案，问题是在某些肯定应该返回 false 的条件下，算法无法终止，因为它会不断检查以前解决的子问题等等。

public boolean isConnected2(int rowCurr, int colCurr) {

            if (rowCurr >= ROWS || rowCurr < 0 || colCurr < 0 || colCurr >= COLS) 
                return false;                  //Base case 1 reached bounds of the 2d array
            if (isEmpty(rowCurr, colCurr))
                return false;
            if (isConnected(rowCurr, colCurr)) // base case 2 current piece is connected according to the method above
                return true;

            else {
                return     isConnected2(rowCurr + 1, colCurr + 1)                                          
                        || isConnected2(rowCurr - 1, colCurr - 1)
                        || isConnected2(rowCurr + 1, colCurr - 1)
                        || isConnected2(rowCurr - 1, colCurr + 1)
                        || isConnected2(rowCurr - 1, colCurr - 1)
                        || isConnected2(rowCurr + 1, colCurr)
                        || isConnected2(rowCurr - 1, colCurr)
                        || isConnected2(rowCurr, colCurr + 1) 
                        || isConnected2(rowCurr, colCurr - 1);
// if any of the above calls returns true we are done


            }

        }

问题是我不确定如何处理导致算法无限递归的特殊情况，而且我确信由于 (||) 运算符的性质，如果有真正的解决方案，它将终止。那么在这种情况下，只处理 StackOverFlow 错误并将其视为方法的错误返回不是更好吗？？

Answer 1

任何递归函数都可以转换为非递归函数。

例如，使用某种队列。将 isConnected2 方法的不同参数推送到队列中，然后不断地从队列中弹出一组参数，并对它们求值。如果该评估导致对函数的更多调用，则将一组新参数推送到队列中。如果队列变得太大或经过一定时间后，您可以终止。

这样您就可以使用堆而不是堆栈，并避免堆栈溢出的可能性。