build

docs/chapter_tree/array_representation_of_tree.md

@@ -151,18 +151,18 @@ comments: true
 
         def __init__(self, arr: list[int | None]):
             """构造方法"""
-            self.__tree = list(arr)
+            self._tree = list(arr)
 
         def size(self):
             """节点数量"""
-            return len(self.__tree)
+            return len(self._tree)
 
         def val(self, i: int) -> int:
             """获取索引为 i 节点的值"""
             # 若索引越界，则返回 None ，代表空位
             if i < 0 or i >= self.size():
                 return None
-            return self.__tree[i]
+            return self._tree[i]
 
         def left(self, i: int) -> int | None:
             """获取索引为 i 节点的左子节点的索引"""
@@ -185,18 +185,18 @@ comments: true
                     self.res.append(self.val(i))
             return self.res
 
-        def __dfs(self, i: int, order: str):
+        def dfs(self, i: int, order: str):
             """深度优先遍历"""
             if self.val(i) is None:
                 return
             # 前序遍历
             if order == "pre":
                 self.res.append(self.val(i))
-            self.__dfs(self.left(i), order)
+            self.dfs(self.left(i), order)
             # 中序遍历
             if order == "in":
                 self.res.append(self.val(i))
-            self.__dfs(self.right(i), order)
+            self.dfs(self.right(i), order)
             # 后序遍历
             if order == "post":
                 self.res.append(self.val(i))
@@ -204,19 +204,19 @@ comments: true
         def pre_order(self) -> list[int]:
             """前序遍历"""
             self.res = []
-            self.__dfs(0, order="pre")
+            self.dfs(0, order="pre")
             return self.res
 
         def in_order(self) -> list[int]:
             """中序遍历"""
             self.res = []
-            self.__dfs(0, order="in")
+            self.dfs(0, order="in")
             return self.res
 
         def post_order(self) -> list[int]:
             """后序遍历"""
             self.res = []
-            self.__dfs(0, order="post")
+            self.dfs(0, order="post")
             return self.res
     ```
 

docs/chapter_tree/avl_tree.md

@@ -229,7 +229,7 @@ AVL 树既是二叉搜索树也是平衡二叉树，同时满足这两类二叉
             return node.height
         return -1
 
-    def __update_height(self, node: TreeNode | None):
+    def update_height(self, node: TreeNode | None):
         """更新节点高度"""
         # 节点高度等于最高子树高度 + 1
         node.height = max([self.height(node.left), self.height(node.right)]) + 1
@@ -636,7 +636,7 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中
 === "Python"
 
     ```python title="avl_tree.py"
-    def __right_rotate(self, node: TreeNode | None) -> TreeNode | None:
+    def right_rotate(self, node: TreeNode | None) -> TreeNode | None:
         """右旋操作"""
         child = node.left
         grand_child = child.right
@@ -644,8 +644,8 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中
         child.right = node
         node.left = grand_child
         # 更新节点高度
-        self.__update_height(node)
-        self.__update_height(child)
+        self.update_height(node)
+        self.update_height(child)
         # 返回旋转后子树的根节点
         return child
     ```
@@ -873,7 +873,7 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中
 === "Python"
 
     ```python title="avl_tree.py"
-    def __left_rotate(self, node: TreeNode | None) -> TreeNode | None:
+    def left_rotate(self, node: TreeNode | None) -> TreeNode | None:
         """左旋操作"""
         child = node.right
         grand_child = child.left
@@ -881,8 +881,8 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中
         child.left = node
         node.right = grand_child
         # 更新节点高度
-        self.__update_height(node)
-        self.__update_height(child)
+        self.update_height(node)
+        self.update_height(child)
         # 返回旋转后子树的根节点
         return child
     ```
@@ -1135,7 +1135,7 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中
 === "Python"
 
     ```python title="avl_tree.py"
-    def __rotate(self, node: TreeNode | None) -> TreeNode | None:
+    def rotate(self, node: TreeNode | None) -> TreeNode | None:
         """执行旋转操作，使该子树重新恢复平衡"""
         # 获取节点 node 的平衡因子
         balance_factor = self.balance_factor(node)
@@ -1143,20 +1143,20 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中
         if balance_factor > 1:
             if self.balance_factor(node.left) >= 0:
                 # 右旋
-                return self.__right_rotate(node)
+                return self.right_rotate(node)
             else:
                 # 先左旋后右旋
-                node.left = self.__left_rotate(node.left)
-                return self.__right_rotate(node)
+                node.left = self.left_rotate(node.left)
+                return self.right_rotate(node)
         # 右偏树
         elif balance_factor < -1:
             if self.balance_factor(node.right) <= 0:
                 # 左旋
-                return self.__left_rotate(node)
+                return self.left_rotate(node)
             else:
                 # 先右旋后左旋
-                node.right = self.__right_rotate(node.right)
-                return self.__left_rotate(node)
+                node.right = self.right_rotate(node.right)
+                return self.left_rotate(node)
         # 平衡树，无须旋转，直接返回
         return node
     ```
@@ -1552,24 +1552,24 @@ AVL 树的节点插入操作与二叉搜索树在主体上类似。唯一的区
     ```python title="avl_tree.py"
     def insert(self, val):
         """插入节点"""
-        self.root = self.__insert_helper(self.root, val)
+        self._root = self.insert_helper(self._root, val)
 
-    def __insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
+    def insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
         """递归插入节点（辅助方法）"""
         if node is None:
             return TreeNode(val)
         # 1. 查找插入位置，并插入节点
         if val < node.val:
-            node.left = self.__insert_helper(node.left, val)
+            node.left = self.insert_helper(node.left, val)
         elif val > node.val:
-            node.right = self.__insert_helper(node.right, val)
+            node.right = self.insert_helper(node.right, val)
         else:
             # 重复节点不插入，直接返回
             return node
         # 更新节点高度
-        self.__update_height(node)
+        self.update_height(node)
         # 2. 执行旋转操作，使该子树重新恢复平衡
-        return self.__rotate(node)
+        return self.rotate(node)
     ```
 
 === "C++"
@@ -1904,17 +1904,17 @@ AVL 树的节点插入操作与二叉搜索树在主体上类似。唯一的区
     ```python title="avl_tree.py"
     def remove(self, val: int):
         """删除节点"""
-        self.root = self.__remove_helper(self.root, val)
+        self._root = self.remove_helper(self._root, val)
 
-    def __remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
+    def remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
         """递归删除节点（辅助方法）"""
         if node is None:
             return None
         # 1. 查找节点，并删除之
         if val < node.val:
-            node.left = self.__remove_helper(node.left, val)
+            node.left = self.remove_helper(node.left, val)
         elif val > node.val:
-            node.right = self.__remove_helper(node.right, val)
+            node.right = self.remove_helper(node.right, val)
         else:
             if node.left is None or node.right is None:
                 child = node.left or node.right
@@ -1929,12 +1929,12 @@ AVL 树的节点插入操作与二叉搜索树在主体上类似。唯一的区
                 temp = node.right
                 while temp.left is not None:
                     temp = temp.left
-                node.right = self.__remove_helper(node.right, temp.val)
+                node.right = self.remove_helper(node.right, temp.val)
                 node.val = temp.val
         # 更新节点高度
-        self.__update_height(node)
+        self.update_height(node)
         # 2. 执行旋转操作，使该子树重新恢复平衡
-        return self.__rotate(node)
+        return self.rotate(node)
     ```
 
 === "C++"

docs/chapter_tree/binary_search_tree.md

@@ -46,7 +46,7 @@ comments: true
     ```python title="binary_search_tree.py"
     def search(self, num: int) -> TreeNode | None:
         """查找节点"""
-        cur = self.__root
+        cur = self._root
         # 循环查找，越过叶节点后跳出
         while cur is not None:
             # 目标节点在 cur 的右子树中
@@ -340,11 +340,11 @@ comments: true
     def insert(self, num: int):
         """插入节点"""
         # 若树为空，则初始化根节点
-        if self.__root is None:
-            self.__root = TreeNode(num)
+        if self._root is None:
+            self._root = TreeNode(num)
             return
         # 循环查找，越过叶节点后跳出
-        cur, pre = self.__root, None
+        cur, pre = self._root, None
         while cur is not None:
             # 找到重复节点，直接返回
             if cur.val == num:
@@ -792,10 +792,10 @@ comments: true
     def remove(self, num: int):
         """删除节点"""
         # 若树为空，直接提前返回
-        if self.__root is None:
+        if self._root is None:
             return
         # 循环查找，越过叶节点后跳出
-        cur, pre = self.__root, None
+        cur, pre = self._root, None
         while cur is not None:
             # 找到待删除节点，跳出循环
             if cur.val == num:
@@ -816,14 +816,14 @@ comments: true
             # 当子节点数量 = 0 / 1 时， child = null / 该子节点
             child = cur.left or cur.right
             # 删除节点 cur
-            if cur != self.__root:
+            if cur != self._root:
                 if pre.left == cur:
                     pre.left = child
                 else:
                     pre.right = child
             else:
                 # 若删除节点为根节点，则重新指定根节点
-                self.__root = child
+                self._root = child
         # 子节点数量 = 2
         else:
             # 获取中序遍历中 cur 的下一个节点