请解释java中给定的二叉树代码

Question

我找不到人来正确地解释这个 java 代码，所以最后我发布了这个问题。请解释该特定语句如何影响树的过程。问题在 cmets 中说明。我在 BST 中有问题类。

 import java.util.Scanner;

 class BSTNode
 {
     BSTNode left, right;
     int data;

     public BSTNode()
     {
         left = null;
         right = null;
         data = 0;
     }

     public BSTNode(int n)
     {
         left = null;
         right = null;
         data = n;
     }

     public void setLeft(BSTNode n)
     {
         left = n;
     }

     public void setRight(BSTNode n)
     {
         right = n;
     }

     public BSTNode getLeft()
     {
         return left;
     }

     public BSTNode getRight()
     {
         return right;
     }

     public void setData(int d)
     {
         data = d;
     }

     public int getData()
     {
         return data;
     }     
 }

 class BST
 {
     private BSTNode root;

     public BST()
     {
         root = null;
     }

     public boolean isEmpty()
     {
         return root == null;
     }

为什么插入函数写成root=insert(.....。每次都返回 root = 实际的根元素吗？

     public void insert(int data)
     {
         root = insert(root, data);
     }

我了解插入过程是如何进行的，但是插入函数返回的是什么？我知道它返回了一些节点，但是在迭代过程中这个过程是如何进行的？

     private BSTNode insert(BSTNode node, int data)
     {
         if (node == null)
             node = new BSTNode(data);
         else
         {
             if (data <= node.getData())
                 node.left = insert(node.left, data);
             else
                 node.right = insert(node.right, data);
         }

         return node;
     }

     public void delete(int k)
     {
         if (isEmpty())
             System.out.println("Tree Empty");
         else if (search(k) == false)
             System.out.println("Sorry "+ k +" is not present");
         else
         {
             root = delete(root, k);

再次，为什么删除函数写成root=delete(.....？每次都返回 root =actual root 元素吗？

             System.out.println(k+ " deleted from the tree");
         }
     }

     private BSTNode delete(BSTNode root, int k)
     {
         BSTNode p, p2, n;

         if (root.getData() == k)
         {
             BSTNode lt, rt;
             lt = root.getLeft();
             rt = root.getRight();

             if (lt == null && rt == null)
                 return null;
             else if (lt == null)
             {
                 p = rt;
                 return p;
             }
             else if (rt == null)
             {
                 p = lt;
                 return p;
             }
             else
             {
                 //case when we delete node having both children.
                 p2 = rt;
                 p = rt;

                 //getting the min of the right child subtree in p variable .
                 while (p.getLeft() != null)
                     p = p.getLeft();

                 p.setLeft(lt);

请解释这里发生了什么以及为什么返回 p2 即 rt。

                 return p2;
             }
         }

         if (k < root.getData())
         {
             n = delete(root.getLeft(), k);
             root.setLeft(n);
         }
         else
         {
             n = delete(root.getRight(), k);
             root.setRight(n);             
         }

         return root;
     }

     public int countNodes()
     {
         return countNodes(root);
     }

Answer 1

在代码的删除部分，您所做的是检查节点（称为根）的数据值是否等于您要删除的值 (k)。如果这是真的，那么你检查你似乎掌握的两个孩子。因此，当您的节点的两个子节点都不是null 时，我们开始回答您的问题。在这种情况下，您想删除您所在子树的当前节点（根），但是您需要选择一个节点（左或右）来提升到该节点的位置。因此（假设这棵树不平衡）您只需选择（左或右）子树以提升到已知根。请记住，您只是调用当前节点根，因为它是较大树中某个子树的根（这并不意味着树的实际根，除非那是作为根传入的值）。知道右子树中的所有值都将大于左子树中的值，您只需获取当前节点的左子树，然后尽可能向下递归右子树的左子树，直到您'到最后。然后将此节点的左子节点设置为整个左子树。

//case when we delete node having both children.
p2 = rt;
p = rt;

//getting the min of the right child subtree in p variable .
while (p.getLeft() != null)
p = p.getLeft();

p.setLeft(lt);

声明中的注意事项

p = rt;

您将 P 设置为右子树的根。那么p现在就是传入的当前根的右孩子了。

while (p.getLeft() != null)
    p = p.getLeft();

p.setLeft(lt);

这基本上是说对于那个右子树，如果根节点有一个左子节点，则将p 设置为该值并继续这样做直到该值为空。这将继续沿该右子树的左子树向下移动。最后，一旦该值为空

p.setLeft(lt);

将右子树中最左边的叶子的左子节点设置为您开始使用的整个左子树。并返回您所说的节点是原始的右子树（现在原始的左子树附加到其最左边的叶子）。