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


            }

        }

问题是我不知道如何处理导致算法无限递归的特殊情况。我确信由于（||）运算符的性质，如果有一个真正的解决方案，IT将终止。那么在这种情况下，仅处理StackOverFlow错误并将其视为方法的错误返回是不是更好？

Answer 1

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

例如，使用某种队列。将不同参数推送到队列中的isConnected2方法，然后从队列中连续弹出一组参数，并对其进行评估。如果该评估导致对该函数的更多调用，则将一组新参数推送到队列。如果队列太大或经过一段时间后，您可以终止。

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

Answer 2

不要让程序中的堆栈溢出。让它发生并捕获它是JVM的巨大负担。修复你的递归，以免它发生。

Answer 3

public boolean isConnected2(int row, int col) {
        int i; int j;
        if (OutOfBounds(row, col)) 
            return false;
        if (isEmpty(row, col))
            return false;
        if (isConnected(row, col)) 
            return true;

        else {

            for (i = row; i > 0; i--)
                if(isConnected(i,col))
                    return true;
                else if(isEmpty(i, col))
                    break;

            for (i = row; i < ROWS; i++)
                if(isConnected(i,col))
                    return true;
                else if(isEmpty(i,col))
                    break;
            for (i = col; i < COLS; i++)
                if(isConnected(row,i))
                    return true;
                else if(isEmpty(row,i))
                    break;
            for (i = col; i > 0; i--)
                if(isConnected(row,i))
                    return true;
                else if(isEmpty(row,i))
                    break;
            for (i = row, j = col; i > 0 && j < COLS; i--, j++)
                if(isConnected(i,j))
                    return true;
                else if(isEmpty(i,j))
                    break;
            for (i = row, j = col; i < ROWS && j > 0; i++, j--)
                if(isConnected(i,j))
                    return true;
                else if(isEmpty(i,j))
                    break;
            for (i = row, j = col; i > 0 && j > 0; i--, j--)
                if(isConnected(i,j))
                    return true;
                else if(isEmpty(i,j))
                    break;
            for (i = row, j = col; i < ROWS && j < COLS; i++, j++)
                if(isConnected(i,j))
                    return true;
                else if(isEmpty(i,j))
                    break;

        }
        return false;

    }

这是同样的方法isConnected2迭代实现它是否类似？现在它只检查2d数组中的每个方向一次，而不是反复向所有方向传播

我应该尝试修复特殊情况还是只捕获stackoverflow错误？

3 个答案: