二叉搜索树&x27；Java中的add方法

我有一段代码，用于在Java中向二进制搜索树插入节点，如：

public class BST {
private Node head;

public BST() {
    this.head = null;
}

public void add(int data, Node head) {
    if (head == null)
        head = new Node(data);
    else {
        if (data < head.data)
            add(data, head.left);
        else
            add(data, head.right);
    }
}

public void add(int data) {
    add(data, this.head);
}

public void preOrder(Node head) {
    if (head != null) {
        System.out.print(head.data + " ");
        preOrder(head.left);
        preOrder(head.right);
    }
}

public void preOrder() {
    preOrder(this.head);
}

public static void main(String[] args) {
    BST bst = new BST();
    for (int i = 0; i < 10; i++) {
        bst.add(i);
    }
    bst.preOrder();
}
}

公共类BST{
专用节点头；
公共BST（）{
this.head=null；
}
公共void添加（int数据，节点头）{
if（head==null）
head=新节点（数据）；
否则{
if（数据<头部数据）
添加（数据，标题。左侧）；
其他的
添加（数据，标题右侧）；
}
}
公共无效添加（整型数据）{
添加（数据，此.head）；
}
公共无效预订单（节点头）{
if（head！=null）{
系统输出打印（head.data+“”）；
前序（头部，左侧）；
前序（右首）；
}
}
公共无效预订单（）{
预订单（本头）；
}
公共静态void main（字符串[]args）{
BST BST=新的BST（）；
对于（int i=0；i<10；i++）{
bst.add（i）；
}
bst.preOrder（）；
}
}

---

为什么我运行程序时不打印我的信息？谢谢你回答我的问题

当递归返回时，不更新左/右指针。此外，局部变量head与实例变量不同。因此，当方法返回时，您创建的新节点将被丢弃

这里有一种方法

private

add

方法返回更新后的节点，该节点在递归返回时被（重新）分配

private Node add(int data, Node node) {
    if (node == null)
        return new Node(data);
    else {
        if (data < node.data)
            node.left = add(data, node.left);
        else
            node.right = add(data, node.right);
    }
   return node;
}

public void add(int data) {
    this.head = add(data, this.head);
}

专用节点添加（int数据，节点）{
if（node==null）
返回新节点（数据）；
否则{
if（数据<节点数据）
node.left=添加（数据，node.left）；
其他的
node.right=添加（数据，node.right）；
}
返回节点；
}
公共无效添加（整型数据）{
this.head=添加（数据，this.head）；
}

当递归返回时，不更新左/右指针。此外，局部变量head与实例变量不同。因此，当方法返回时，您创建的新节点将被丢弃

这里有一种方法

private

add

方法返回更新后的节点，该节点在递归返回时被（重新）分配

private Node add(int data, Node node) {
    if (node == null)
        return new Node(data);
    else {
        if (data < node.data)
            node.left = add(data, node.left);
        else
            node.right = add(data, node.right);
    }
   return node;
}

public void add(int data) {
    this.head = add(data, this.head);
}

专用节点添加（int数据，节点）{
if（node==null）
返回新节点（数据）；
否则{
if（数据<节点数据）
node.left=添加（数据，node.left）；
其他的
node.right=添加（数据，node.right）；
}
返回节点；
}
公共无效添加（整型数据）{
this.head=添加（数据，this.head）；
}

这里是另一个选项：

  public void add(int data) {
    if(head == null) {
      this.head = new Node(data);
    }
    else {
      add(data, this.head);
    }
  }

  public void add(int data, Node node) {
    if(data < node.data) {
      if(node.left == null) {
        node.left = new Node(data);
      }
      else {
        add(data, node.left);
      }
    }
    else {
      if(node.right == null) {
        node.right = new Node(data);
      }
      else {
        add(data, node.right);
      }
    }
  }

public void add（整数数据）{
if（head==null）{
this.head=新节点（数据）；
}
否则{
添加（数据，此.head）；
}
}
公共void添加（int数据，节点）{
if（数据<节点数据）{
if（node.left==null）{
node.left=新节点（数据）；
}
否则{
添加（数据，节点，左侧）；
}
}
否则{
if（node.right==null）{
node.right=新节点（数据）；
}
否则{
添加（数据，节点.右侧）；
}
}
}

这里是另一个选项：

  public void add(int data) {
    if(head == null) {
      this.head = new Node(data);
    }
    else {
      add(data, this.head);
    }
  }

  public void add(int data, Node node) {
    if(data < node.data) {
      if(node.left == null) {
        node.left = new Node(data);
      }
      else {
        add(data, node.left);
      }
    }
    else {
      if(node.right == null) {
        node.right = new Node(data);
      }
      else {
        add(data, node.right);
      }
    }
  }

public void add（整数数据）{
if（head==null）{
this.head=新节点（数据）；
}
否则{
添加（数据，此.head）；
}
}
公共void添加（int数据，节点）{
if（数据<节点数据）{
if（node.left==null）{
node.left=新节点（数据）；
}
否则{
添加（数据，节点，左侧）；
}
}
否则{
if（node.right==null）{
node.right=新节点（数据）；
}
否则{
添加（数据，节点.右侧）；
}
}
}

当递归返回时，不更新左/右指针。此外，局部变量

head

与实例变量不同。当递归返回时，不更新左/右指针。此外，局部变量

head

与实例变量不同。