我應該嘗試修復特殊情況還是只捕獲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


            }

        }

問題是我不知道如何處理導致算法無限遞歸的特殊情況。我確信由於（||）運算符的性質，如果有一個真正的解決方案，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數組中的每個方向一次，而不是重復地在所有方向上傳播