java五子棋如何判断输赢

一、Java五子棋如何判断输赢

在Java五子棋游戏中，判断输赢可以通过以下几种方法：线性扫描、递归算法、矩阵遍历。其中，线性扫描是最常用的方式，因为它简单且高效。具体来说，线性扫描可以通过检查每个棋子在横向、纵向、以及两个对角线方向上是否有连续的五个相同棋子来判断是否有玩家获胜。接下来，我们将详细介绍这些方法，并通过代码示例来帮助理解。

二、线性扫描方法

线性扫描方法是通过遍历棋盘上的每一个位置，然后从每个位置开始，分别向四个方向（横向、纵向、左上到右下对角线、右上到左下对角线）检查是否有连续的五个相同棋子。

1. 横向检查

横向检查是从当前棋子开始，向右检查是否有连续的五个相同棋子。

private boolean checkHorizontal(int[][] board, int x, int y, int player) {
    int count = 0;
    for (int i = 0; i < 5; i++) {
        if (x + i < board.length && board[x + i][y] == player) {
            count++;
        } else {
            break;
        }
    }
    return count == 5;
}

2. 纵向检查

纵向检查是从当前棋子开始，向下检查是否有连续的五个相同棋子。

private boolean checkVertical(int[][] board, int x, int y, int player) {
    int count = 0;
    for (int i = 0; i < 5; i++) {
        if (y + i < board[0].length && board[x][y + i] == player) {
            count++;
        } else {
            break;
        }
    }
    return count == 5;
}

3. 左上到右下对角线检查

左上到右下对角线检查是从当前棋子开始，向右下方向检查是否有连续的五个相同棋子。

private boolean checkDiagonal1(int[][] board, int x, int y, int player) {
    int count = 0;
    for (int i = 0; i < 5; i++) {
        if (x + i < board.length && y + i < board[0].length && board[x + i][y + i] == player) {
            count++;
        } else {
            break;
        }
    }
    return count == 5;
}

4. 右上到左下对角线检查

右上到左下对角线检查是从当前棋子开始，向左下方向检查是否有连续的五个相同棋子。

private boolean checkDiagonal2(int[][] board, int x, int y, int player) {
    int count = 0;
    for (int i = 0; i < 5; i++) {
        if (x - i >= 0 && y + i < board[0].length && board[x - i][y + i] == player) {
            count++;
        } else {
            break;
        }
    }
    return count == 5;
}

5. 综合检查

为了判断某个棋子是否让玩家获胜，我们需要综合以上四种检查方法。

private boolean checkWin(int[][] board, int x, int y, int player) {
    return checkHorizontal(board, x, y, player) || 
           checkVertical(board, x, y, player) || 
           checkDiagonal1(board, x, y, player) || 
           checkDiagonal2(board, x, y, player);
}

三、递归算法

递归算法是一种较为复杂但也非常有效的方法。它通过递归地检查每个棋子在各个方向上的连续情况来判断是否有玩家获胜。

1. 横向递归检查

横向递归检查是从当前棋子开始，递归地向右检查是否有连续的五个相同棋子。

private boolean checkHorizontalRecursive(int[][] board, int x, int y, int player, int count) {
    if (count == 5) return true;
    if (x >= board.length || board[x][y] != player) return false;
    return checkHorizontalRecursive(board, x + 1, y, player, count + 1);
}

2. 纵向递归检查

纵向递归检查是从当前棋子开始，递归地向下检查是否有连续的五个相同棋子。

private boolean checkVerticalRecursive(int[][] board, int x, int y, int player, int count) {
    if (count == 5) return true;
    if (y >= board[0].length || board[x][y] != player) return false;
    return checkVerticalRecursive(board, x, y + 1, player, count + 1);
}

3. 左上到右下对角线递归检查

左上到右下对角线递归检查是从当前棋子开始，递归地向右下方向检查是否有连续的五个相同棋子。

private boolean checkDiagonal1Recursive(int[][] board, int x, int y, int player, int count) {
    if (count == 5) return true;
    if (x >= board.length || y >= board[0].length || board[x][y] != player) return false;
    return checkDiagonal1Recursive(board, x + 1, y + 1, player, count + 1);
}

4. 右上到左下对角线递归检查

右上到左下对角线递归检查是从当前棋子开始，递归地向左下方向检查是否有连续的五个相同棋子。

private boolean checkDiagonal2Recursive(int[][] board, int x, int y, int player, int count) {
    if (count == 5) return true;
    if (x < 0 || y >= board[0].length || board[x][y] != player) return false;
    return checkDiagonal2Recursive(board, x - 1, y + 1, player, count + 1);
}

5. 综合递归检查

为了判断某个棋子是否让玩家获胜，我们需要综合以上四种递归检查方法。

private boolean checkWinRecursive(int[][] board, int x, int y, int player) {
    return checkHorizontalRecursive(board, x, y, player, 0) || 
           checkVerticalRecursive(board, x, y, player, 0) || 
           checkDiagonal1Recursive(board, x, y, player, 0) || 
           checkDiagonal2Recursive(board, x, y, player, 0);
}

四、矩阵遍历方法

矩阵遍历方法是通过遍历整个棋盘，对每一个棋子进行上述的四种方向检查，来判断是否有玩家获胜。

1. 棋盘初始化

首先，我们需要初始化棋盘，这里以15×15的棋盘为例。

int[][] board = new int[15][15];

2. 棋盘遍历检查

然后，我们遍历棋盘上的每一个位置，检查是否有玩家获胜。

private boolean checkBoard(int[][] board, int player) {
    for (int x = 0; x < board.length; x++) {
        for (int y = 0; y < board[0].length; y++) {
            if (board[x][y] == player) {
                if (checkWin(board, x, y, player)) {
                    return true;
                }
            }
        }
    }
    return false;
}

五、完整代码示例

以下是一个完整的Java代码示例，整合了以上所有方法来判断五子棋的输赢。

public class FiveInARow {
    private int[][] board;
    private int size;
    public FiveInARow(int size) {
        this.size = size;
        this.board = new int[size][size];
    }
    private boolean checkHorizontal(int[][] board, int x, int y, int player) {
        int count = 0;
        for (int i = 0; i < 5; i++) {
            if (x + i < board.length && board[x + i][y] == player) {
                count++;
            } else {
                break;
            }
        }
        return count == 5;
    }
    private boolean checkVertical(int[][] board, int x, int y, int player) {
        int count = 0;
        for (int i = 0; i < 5; i++) {
            if (y + i < board[0].length && board[x][y + i] == player) {
                count++;
            } else {
                break;
            }
        }
        return count == 5;
    }
    private boolean checkDiagonal1(int[][] board, int x, int y, int player) {
        int count = 0;
        for (int i = 0; i < 5; i++) {
            if (x + i < board.length && y + i < board[0].length && board[x + i][y + i] == player) {
                count++;
            } else {
                break;
            }
        }
        return count == 5;
    }
    private boolean checkDiagonal2(int[][] board, int x, int y, int player) {
        int count = 0;
        for (int i = 0; i < 5; i++) {
            if (x - i >= 0 && y + i < board[0].length && board[x - i][y + i] == player) {
                count++;
            } else {
                break;
            }
        }
        return count == 5;
    }
    private boolean checkWin(int[][] board, int x, int y, int player) {
        return checkHorizontal(board, x, y, player) || 
               checkVertical(board, x, y, player) || 
               checkDiagonal1(board, x, y, player) || 
               checkDiagonal2(board, x, y, player);
    }
    public boolean checkBoard(int[][] board, int player) {
        for (int x = 0; x < board.length; x++) {
            for (int y = 0; y < board[0].length; y++) {
                if (board[x][y] == player) {
                    if (checkWin(board, x, y, player)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    public static void main(String[] args) {
        FiveInARow game = new FiveInARow(15);
        // Initialize the board with some moves
        // Example: game.board[0][0] = 1; // Player 1's move
        // Example: game.board[1][1] = 2; // Player 2's move
        // Check if player 1 wins
        boolean player1Wins = game.checkBoard(game.board, 1);
        System.out.println("Player 1 wins: " + player1Wins);
        // Check if player 2 wins
        boolean player2Wins = game.checkBoard(game.board, 2);
        System.out.println("Player 2 wins: " + player2Wins);
    }
}

这个代码示例展示了如何在一个15×15的五子棋棋盘上，通过线性扫描方法来判断玩家是否获胜。通过这个例子，你可以了解到如何初始化棋盘、检查棋盘上的每一个位置，以及判断是否有玩家获胜。