Java中具有递归的堆栈溢出

Question

I'm trying to write an AI that never loses at Tic Tac Toe, and I want to use the minimax algorithm to do so. However, when I try to run the program, a stack overflow appears and I can't seem to find what is the error. Could you take a look and tell me what I'm doing wrong? It doesn't go as deep in the recursion I believe, since it should only go through all the possible game outcomes, which go up to 8 moves (since the player is first to play, not the AI). It is probably me doing something wrong, but I can't find anything.

EDIT: Here's the full code, the mechanics function is the main part: EDIT2: Fixed the constructor

package Packet;
import java.util.*;
import java.util.Scanner;

public class Logic {

public static class TicTacToe{

    private int[] currentBoard = new int[9];
    private int[] availableSpots = new int [9];

    private int emptySpace = 0;
    private int playerAI = 1;
    private int playerHuman = 2;


    void TicTacToe(){
        for (int i = 0; i < 9; i++){
            this.currentBoard[i] = this.emptySpace;
        }
        for (int i = 0; i < 9; i++){
            this.availableSpots[i] = i;
        }
    }

    private int movesNumber(){
        int counter = 0;
        for (int i = 0; i < 9; i++){
            if (this.currentBoard[i] == this.emptySpace){
                counter++;
            }
        }
        return counter;
    }

    private boolean win(int[] board,int player){
        if (
        (board[0] == player && board[1] == player && board[2] == player) ||
        (board[3] == player && board[4] == player && board[5] == player) ||
        (board[6] == player && board[7] == player && board[8] == player) ||
        (board[0] == player && board[3] == player && board[6] == player) ||
        (board[1] == player && board[4] == player && board[7] == player) ||
        (board[2] == player && board[5] == player && board[8] == player) ||
        (board[0] == player && board[4] == player && board[8] == player) ||
        (board[2] == player && board[4] == player && board[6] == player) ){
            return true;
        }
        else{
            return false;
        }
    }

    private int mechanics(int[] newBoard, int player){
        if (win(newBoard,this.playerHuman)){
            return -10;
        }
        else if (win(newBoard, this.playerAI)){
            return +10;
        }
        else if (this.movesNumber() == 0){
            return 0;
        }

        ArrayList<Integer> moves = new ArrayList<Integer>();
        ArrayList<Integer> scores = new ArrayList<Integer>();


        for (int i = 0; i < this.movesNumber(); i++){
            int[] possibleBoard = new int[9];
            possibleBoard = newBoard;           

            int availableSpotNumber = i;

            int j = i;

            while (this.availableSpots[j] == 9){
                availableSpotNumber++;
                j++;
            }

            possibleBoard[availableSpotNumber] = player;

            if (player == this.playerAI){
                scores.add(this.mechanics(possibleBoard, this.playerHuman));
            }
            else{
                scores.add(this.mechanics(possibleBoard, this.playerAI));
            }
            moves.add(availableSpotNumber);

            possibleBoard[availableSpotNumber] = this.emptySpace;
        }

        int bestMove = 0;

        if (player == this.playerAI){
            int bestScore = -10000;
            for (int i = 0; i < moves.size(); i++){
                if (scores.get(i) > bestScore){
                    bestScore = scores.get(i);
                    bestMove = i;
                }
            }
        }
        else {
            int bestScore = 10000;
            for (int i = 0; i < moves.size(); i++){
                if (scores.get(i) < bestScore){
                    bestScore = scores.get(i);
                    bestMove = i;
                }
            }
        }
        return moves.get(bestMove);
    }

    public void printTable(){
        System.out.println(this.currentBoard[0] + " | " + this.currentBoard[1] + " | " + this.currentBoard[2]);
        System.out.println("-   -   -");
        System.out.println(this.currentBoard[3] + " | " + this.currentBoard[4] + " | " + this.currentBoard[5]);
        System.out.println("-   -   -");
        System.out.println(this.currentBoard[6] + " | " + this.currentBoard[7] + " | " + this.currentBoard[8]);
        System.out.println();
    }

    private void fillTable(int position,int player){
        this.currentBoard[position] = player;
        this.availableSpots[position] = 9;
    }

    public void startGame(){
        while(true){
            this.printTable();
            Scanner ulaz = new Scanner(System.in);
            fillTable(ulaz.nextInt(), this.playerHuman);
            this.printTable();
            fillTable(this.mechanics(this.currentBoard, this.playerAI), this.playerAI);
            ulaz.close();
        }
    }

    public void resetGame(){
        for (int i = 0; i < 9; i++){
            this.currentBoard[i] = this.emptySpace;
        }
        for (int i = 0; i < 9; i++){
            this.availableSpots[i] = i;
        }
    }
}

public static void main(String[] args){
    TicTacToe game = new TicTacToe();
    game.startGame();
}
}

Also, here's the exact errors I get:

Exception in thread "main" java.lang.StackOverflowError
    at Packet.Logic$TicTacToe.mechanics(Logic.java:54)
    at Packet.Logic$TicTacToe.mechanics(Logic.java:84)
    at Packet.Logic$TicTacToe.mechanics(Logic.java:87)
    at Packet.Logic$TicTacToe.mechanics(Logic.java:84)
    at Packet.Logic$TicTacToe.mechanics(Logic.java:87)
    at Packet.Logic$TicTacToe.mechanics(Logic.java:84)
    at Packet.Logic$TicTacToe.mechanics(Logic.java:87)

After this part, these parts appear a bunch of times (at least 50)

at Packet.Logic$TicTacToe.mechanics(Logic.java:84)
at Packet.Logic$TicTacToe.mechanics(Logic.java:87) 

Line 54:

if (win(newBoard,this.playerHuman)){

Line 84:

scores.add(this.mechanics(possibleBoard, this.playerHuman));

Line 87:

scores.add(this.mechanics(possibleBoard, this.playerAI));

Answer 1

There's a couple of problems, but here's how you can debug this:

add a StringBuilder debug = new StringBuilder(); field to your class, then change the main loop like this:

int debugLen = debug.length();
debug.append("\nSetting ").append(availableSpotNumber).append(" to ").append(player);
possibleBoard[availableSpotNumber] = player;

try {
    if (player == this.playerAI) {
        scores.add(this.mechanics(possibleBoard, this.playerHuman));
    } else {
        scores.add(this.mechanics(possibleBoard, this.playerAI));
    }
    moves.add(availableSpotNumber);
} catch (StackOverflowError error) {
     throw new StackOverflowError(debug.toString());
}

debug.setLength(debugLen);
possibleBoard[availableSpotNumber] = this.emptySpace;

Then you will see what is happening, which will give you a clue what to fix next. For example, the current version is doing this, for initial human move 1:

Setting 0 to 1
Setting 0 to 2
Setting 0 to 1
Setting 0 to 2
etc..

But, if you're too lazy, you can find a fixed version here .

Answer 2

This might or might not be a code issue, as Java is not a fully functional language with it comes to recursion, you might want to see this answer: Does Java 8 have tail call optimization?

Basically, a language that allows for unlimited-depth recursion has to have tail recursion optimization. With tail call optimization, if the return value is the result of exactly the same function with different parameters, the stack will get replaced instead of the new call being added to the stack.

If a language does not have tail call optimization, then you're limited by stack size in how deep your recursion goes, even if the recursive calls have correct termination conditions (note: I haven't analyzed the code in depth, so obviously there might be a problem in the recursive logic itself). If you want to tweak the stack size, use the -Xss Java runtime parameter. Generally, increasing the stack size is a good heuristic (although not a fool-proof method) of checking whether the fault is with the language or with your algorithm.