請解釋給定的java中的二叉樹代碼

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 即 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)。 如果這是真的，那么你檢查你似乎抓住的兩個孩子。 因此，當您的節點的兩個子節點都為 not 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);

將右子樹中最左邊的葉子的左子樹設置為您開始使用的整個左子樹。 並返回您所說的節點是原始節點的右子樹（現在將原始節點的左子樹附加到其最左側的葉子上）。