Question

我找不到人们正确地解释这个java代码所以最后我发布了这个问题。请解释该特定语句如何影响树的过程。问题在评论中说明。我在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 =实际的根元素吗？

             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即返回。

                 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时，我们就会回答你的问题。在这种情况下，您要删除所在子树的当前节点（根），但是您需要选择一个节点（左侧或右侧）以提升到此节点的位置。所以（假设这棵树不平衡）你只需要选择（左或右）子树来促进知道根。请记住，您只调用当前节点root，因为它是较大树中某个子树的根（这并不意味着树的实际根，除非这是以root身份传入的值）。知道正确子子树中的所有值都将大于左子子树中的值，您只需获取当前节点的左子树，然后向右递归到右子树的左子项，直到您可以到最后。然后，将此节点的左子节点设置为整个左子树。

//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设置为该值并继续这样做，直到该值为空。这将继续沿着正确子树的左边孩子走下去。最后一旦该值为null

p.setLeft(lt);

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

请解释java

1 个答案: