Java二叉搜索树(BST)修改Node访问修饰符后运行异常问题求助

核心错误点 #

• 递归插入逻辑缺失节点关联：你调用insertNode递归插入左右子节点时，没有将递归返回的新节点通过setLeft/setRight绑定到父节点上，导致除根节点外所有插入的节点都没有挂载到树上，这是改完访问修饰符后功能失效的核心原因。之前属性为public时你大概率是直接通过node.left = insertNode(xxx)完成赋值，改private后你遗漏了setter调用步骤。
• 中序遍历的全局列表未清空：你把存储遍历结果的nodes设为类成员变量，每次调用中序遍历前没有清空历史数据，多次调用会出现结果累加的问题。
• 测试用例本身存在逻辑错误：
  • isInsertWorking测试：刚实例化的BinaryTree默认root就是null，你没有调用插入方法就直接断言非空，必然失败。
  • isSearchWorking测试：你插入的节点值为10、30、35、29，不存在值为20的节点，搜索20返回null属于正常逻辑，你的断言预期为root节点本身就不成立。
  • inOrderTraversalPrint测试：你没有插入值为20的节点，预期结果里包含20不符合实际插入数据。

修复代码 #

1. 修正BinaryTree类的插入与遍历逻辑 #

import java.util.ArrayList;
import java.util.List;

public class BinaryTree {
  private Node root;
  private List<Integer> nodes = new ArrayList<>();

  public BinaryTree() {
    root = null;
  }

  public Node getRoot() {
    return root;
  }

  private Node insertNode(Node node, int dataBeingInserted) {
    if (node == null) {
      node = new Node(dataBeingInserted);
      return node;
    }
    if (node.getData() > dataBeingInserted) {
      // 修复：将递归返回的左子节点绑定到当前节点
      node.setLeft(insertNode(node.getLeft(), dataBeingInserted));
    } else if (node.getData() < dataBeingInserted) {
      // 修复：将递归返回的右子节点绑定到当前节点
      node.setRight(insertNode(node.getRight(), dataBeingInserted));
    }
    return node;
  }

  public void insertNode(int dataBeingInserted) {
    root = insertNode(root, dataBeingInserted);
  }

  private Node searchTree(Node node, int dataBeingSearched) {
    if (node == null || node.getData() == dataBeingSearched) {
      return node;
    }
    if (node.getData() > dataBeingSearched) {
      return searchTree(node.getLeft(), dataBeingSearched);
    }
    return searchTree(node.getRight(), dataBeingSearched);
  }

  public Node searchTree(int dataBeingSearched) {
    return searchTree(root, dataBeingSearched);
  }

  private String inorderTraversal(Node node) {
    if (node == null) {
      return "";
    }
    inorderTraversal(node.getLeft());
    nodes.add(node.getData());
    inorderTraversal(node.getRight());
    return nodes.toString();
  }

  public String inorderTraversal() {
    nodes.clear(); // 修复：每次遍历前清空历史结果
    return inorderTraversal(root);
  }
}

2. 修正测试用例逻辑 #

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;

class BinaryTreeTests {
  @Test
  void isSearchWorking() {
    BinaryTree tree = new BinaryTree();
    tree.insertNode(10);
    tree.insertNode(30);
    tree.insertNode(35);
    tree.insertNode(29);
    // 修复：搜索存在的10，预期返回根节点；搜索不存在的20预期返回null
    assertEquals(tree.getRoot(), tree.searchTree(10));
    assertNull(tree.searchTree(20));
  }

  @Test
  void isInsertWorking() {
    BinaryTree tree = new BinaryTree();
    // 修复：插入节点后再断言root非空
    tree.insertNode(5);
    assertNotNull(tree.getRoot());
  }

  @Test
  void inOrderTraversalPrint() {
    BinaryTree tree = new BinaryTree();
    tree.insertNode(10);
    tree.insertNode(30);
    tree.insertNode(35);
    tree.insertNode(29);
    // 修复：移除预期中不存在的20，实际插入的四个节点中序遍历结果为[10, 29, 30, 35]
    assertEquals("[10, 29, 30, 35]", tree.inorderTraversal());
  }

  @Test
  void inOrderTraversalSameElement() {
    BinaryTree tree = new BinaryTree();
    tree.insertNode(1);
    tree.insertNode(1);
    tree.insertNode(1);
    tree.insertNode(1);
    tree.insertNode(1);
    tree.insertNode(1);
    assertEquals("[1]", tree.inorderTraversal());
  }

}

内容的提问来源于stack exchange，提问作者Jebvam Ust