Java 二叉搜索树的Alpha-Beta剪枝

我正在用Alpha-Beta剪枝示例研究Minimax算法。在本例中，他们使用一个数组来实现搜索树。我遵循了这个示例，但也尝试用二叉搜索树来实现它。下面是我在树中使用的值：3，5，6，9，1，2，0，-1

最后的最佳值应为5。随着BST的实现，我不断得到2

我认为这就是问题所在，但我不知道如何解决：
我编写的代码是，如果在尝试检查下一个值时发现叶节点停止获取空指针异常，则返回递归。但是相反，我认为它停止搜索太早了（根据我在使用调试器遍历代码时看到的情况）。但是，如果我删除该检查，代码将在空指针上失败

有人能给我指出正确的方向吗？我做错了什么

代码如下：

public class AlphaBetaMiniMax {

    private static BinarySearchTree myTree = new BinarySearchTree();
    static int MAX = 1000;
    static int MIN = -1000;
    static int opt;

    public static void main(String[] args) {
        //Start constructing the game
        AlphaBetaMiniMax demo = new AlphaBetaMiniMax();

        //3, 5, 6, 9, 1, 2, 0, -1
        demo.myTree.insert(3);
        demo.myTree.insert(5);
        demo.myTree.insert(6);
        demo.myTree.insert(9);
        demo.myTree.insert(1);
        demo.myTree.insert(2);
        demo.myTree.insert(0);
        demo.myTree.insert(-1);

        //print the tree
        System.out.println("Game Tree: ");
        demo.myTree.printTree(demo.myTree.root);

        //Print the results of the game
        System.out.println("\nGame Results:");

        //run the  minimax algorithm with the following inputs
        int optimalVal = demo.minimax(0, myTree.root, true, MAX, MIN);
        System.out.println("Optimal Value: " + optimalVal);

    }

    /**
     * @param alpha = 1000
     * @param beta = -1000
     * @param nodeIndex - the current node
     * @param depth - the depth to search
     * @param maximizingPlayer - the current player making a move
     * @return - the best move for the current player
     */
    public int minimax(int depth, MiniMaxNode nodeIndex, boolean maximizingPlayer, double alpha, double beta) {

        //Base Case #1: Reached the bottom of the tree
        if (depth == 2) {
            return nodeIndex.getValue();
        }

        //Base Case #2: if reached a leaf node, return the value of the current node
        if (nodeIndex.getLeft() == null && maximizingPlayer == false) {
            return nodeIndex.getValue();
        } else if (nodeIndex.getRight() == null && maximizingPlayer == true) {
            return nodeIndex.getValue();
        }

        //Mini-Max Algorithm
        if (maximizingPlayer) {
            int best = MIN;

            //Recur for left and right children
            for (int i = 0; i < 2; i++) {

                int val = minimax(depth + 1, nodeIndex.getLeft(), false, alpha, beta);
                best = Math.max(best, val);
                alpha = Math.max(alpha, best);

                //Alpha Beta Pruning
                if (beta <= alpha) {
                    break;
                }
            }
            return best;
        } else {
            int best = MAX;

            //Recur for left and right children
            for (int i = 0; i < 2; i++) {

                int val = minimax(depth + 1, nodeIndex.getRight(), true, alpha, beta);
                best = Math.min(best, val);
                beta = Math.min(beta, best);

                //Alpha Beta Pruning
                if (beta <= alpha) {
                    break;
                }
            }
            return best;
        }
    }
}

---

您的问题是迭代依赖于循环控件2，而不是nodeIndex.getRight（）（对于max）getLeft（对于min.）的node==null查找

记住一棵树 1人（一级）

第二级=2

第三级=4

第4节8 等等因此，循环算法甚至不会下降3级

for (int i = 0; i < 2; i++) {

     int val = minimax(depth + 1, nodeIndex.getLeft(), false, alpha, beta);
                best = Math.max(best, val);
                alpha = Math.max(alpha, best);

                //Alpha Beta Pruning
                if (beta <= alpha) {
                    break;
                }

for（int i=0；i<2；i++）{
int val=minimax（深度+1，nodeIndex.getLeft（），false，alpha，beta）；
最佳=数学最大值（最佳，val）；
alpha=数学最大值（alpha，最佳值）；
//α-β修剪
如果（beta你能发布一个包含输入的完整代码吗？@kelalaka我编辑了我的帖子以包含输入和输出。我想我可能已经发现了部分问题，但我仍然得到了一个值2。我想另一个问题是，我认为每次运行时，我没有检查树的两侧。我要么检查了左侧，要么检查了右侧——不是全部检查dren。我仍在试图找出如何解决这个问题。这是有意义的。因此，我没有使用for循环，而是尝试了以下方法：在左侧节点上运行miniMax（），然后在右侧节点上运行calculate best>calculate alpha>calculate beta（）。我的逻辑是执行类似于打印树遍历的操作（递归调用print）（node.left）>打印节点值>递归调用print（node.right））。尽管如此，我还是得到了2。我至少在正确的轨道上吗？这是正确的，您需要一个遍历来查找BST的最小值（最左侧节点）和最大值（最右侧节点）使用将完全遍历树左侧和右侧的迭代来查找值。是的，您在正确的轨道上，不要使用for循环来迭代树。这就是nodeIndex.left和nodeIndex.right或getleft和getright所做的。请使用链接来更深入地解释BST树和功能当然，如果我帮你解决了问题，请把答案写在上面。我知道了！谢谢你的帮助。
for (int i = 0; i < 2; i++) {

     int val = minimax(depth + 1, nodeIndex.getLeft(), false, alpha, beta);
                best = Math.max(best, val);
                alpha = Math.max(alpha, best);

                //Alpha Beta Pruning
                if (beta <= alpha) {
                    break;
                }