refactor: Replace 结点 with 节点 (#452)

* Replace 结点 with 节点
Update the footnotes in the figures

* Update mindmap

* Reduce the size of the mindmap.png

codes/swift/chapter_tree/avl_tree.swift

@@ -8,25 +8,25 @@ import utils
 
 /* AVL 树 */
 class AVLTree {
-    fileprivate var root: TreeNode? // 根结点
+    fileprivate var root: TreeNode? // 根节点
 
-    /* 获取结点高度 */
+    /* 获取节点高度 */
     func height(node: TreeNode?) -> Int {
-        // 空结点高度为 -1 ，叶结点高度为 0
+        // 空节点高度为 -1 ，叶节点高度为 0
         node == nil ? -1 : node!.height
     }
 
-    /* 更新结点高度 */
+    /* 更新节点高度 */
     private func updateHeight(node: TreeNode?) {
-        // 结点高度等于最高子树高度 + 1
+        // 节点高度等于最高子树高度 + 1
         node?.height = max(height(node: node?.left), height(node: node?.right)) + 1
     }
 
     /* 获取平衡因子 */
     func balanceFactor(node: TreeNode?) -> Int {
-        // 空结点平衡因子为 0
+        // 空节点平衡因子为 0
         guard let node = node else { return 0 }
-        // 结点平衡因子 = 左子树高度 - 右子树高度
+        // 节点平衡因子 = 左子树高度 - 右子树高度
         return height(node: node.left) - height(node: node.right)
     }
 
@@ -37,10 +37,10 @@ class AVLTree {
         // 以 child 为原点，将 node 向右旋转
         child?.right = node
         node?.left = grandChild
-        // 更新结点高度
+        // 更新节点高度
         updateHeight(node: node)
         updateHeight(node: child)
-        // 返回旋转后子树的根结点
+        // 返回旋转后子树的根节点
         return child
     }
 
@@ -51,16 +51,16 @@ class AVLTree {
         // 以 child 为原点，将 node 向左旋转
         child?.left = node
         node?.right = grandChild
-        // 更新结点高度
+        // 更新节点高度
         updateHeight(node: node)
         updateHeight(node: child)
-        // 返回旋转后子树的根结点
+        // 返回旋转后子树的根节点
         return child
     }
 
     /* 执行旋转操作，使该子树重新恢复平衡 */
     private func rotate(node: TreeNode?) -> TreeNode? {
-        // 获取结点 node 的平衡因子
+        // 获取节点 node 的平衡因子
         let balanceFactor = balanceFactor(node: node)
         // 左偏树
         if balanceFactor > 1 {
@@ -88,48 +88,48 @@ class AVLTree {
         return node
     }
 
-    /* 插入结点 */
+    /* 插入节点 */
     @discardableResult
     func insert(val: Int) -> TreeNode? {
         root = insertHelper(node: root, val: val)
         return root
     }
 
-    /* 递归插入结点（辅助方法） */
+    /* 递归插入节点（辅助方法） */
     private func insertHelper(node: TreeNode?, val: Int) -> TreeNode? {
         var node = node
         if node == nil {
             return TreeNode(x: val)
         }
-        /* 1. 查找插入位置，并插入结点 */
+        /* 1. 查找插入位置，并插入节点 */
         if val < node!.val {
             node?.left = insertHelper(node: node?.left, val: val)
         } else if val > node!.val {
             node?.right = insertHelper(node: node?.right, val: val)
         } else {
-            return node // 重复结点不插入，直接返回
+            return node // 重复节点不插入，直接返回
         }
-        updateHeight(node: node) // 更新结点高度
+        updateHeight(node: node) // 更新节点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node: node)
-        // 返回子树的根结点
+        // 返回子树的根节点
         return node
     }
 
-    /* 删除结点 */
+    /* 删除节点 */
     @discardableResult
     func remove(val: Int) -> TreeNode? {
         root = removeHelper(node: root, val: val)
         return root
     }
 
-    /* 递归删除结点（辅助方法） */
+    /* 递归删除节点（辅助方法） */
     private func removeHelper(node: TreeNode?, val: Int) -> TreeNode? {
         var node = node
         if node == nil {
             return nil
         }
-        /* 1. 查找结点，并删除之 */
+        /* 1. 查找节点，并删除之 */
         if val < node!.val {
             node?.left = removeHelper(node: node?.left, val: val)
         } else if val > node!.val {
@@ -137,59 +137,59 @@ class AVLTree {
         } else {
             if node?.left == nil || node?.right == nil {
                 let child = node?.left != nil ? node?.left : node?.right
-                // 子结点数量 = 0 ，直接删除 node 并返回
+                // 子节点数量 = 0 ，直接删除 node 并返回
                 if child == nil {
                     return nil
                 }
-                // 子结点数量 = 1 ，直接删除 node
+                // 子节点数量 = 1 ，直接删除 node
                 else {
                     node = child
                 }
             } else {
-                // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+                // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
                 let temp = getInOrderNext(node: node?.right)
                 node?.right = removeHelper(node: node?.right, val: temp!.val)
                 node?.val = temp!.val
             }
         }
-        updateHeight(node: node) // 更新结点高度
+        updateHeight(node: node) // 更新节点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node: node)
-        // 返回子树的根结点
+        // 返回子树的根节点
         return node
     }
 
-    /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+    /* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
     private func getInOrderNext(node: TreeNode?) -> TreeNode? {
         var node = node
         if node == nil {
             return node
         }
-        // 循环访问左子结点，直到叶结点时为最小结点，跳出
+        // 循环访问左子节点，直到叶节点时为最小节点，跳出
         while node?.left != nil {
             node = node?.left
         }
         return node
     }
 
-    /* 查找结点 */
+    /* 查找节点 */
     func search(val: Int) -> TreeNode? {
         var cur = root
         while cur != nil {
-            // 目标结点在 cur 的右子树中
+            // 目标节点在 cur 的右子树中
             if cur!.val < val {
                 cur = cur?.right
             }
-            // 目标结点在 cur 的左子树中
+            // 目标节点在 cur 的左子树中
             else if cur!.val > val {
                 cur = cur?.left
             }
-            // 找到目标结点，跳出循环
+            // 找到目标节点，跳出循环
             else {
                 break
             }
         }
-        // 返回目标结点
+        // 返回目标节点
         return cur
     }
 }
@@ -198,13 +198,13 @@ class AVLTree {
 enum _AVLTree {
     static func testInsert(tree: AVLTree, val: Int) {
         tree.insert(val: val)
-        print("\n插入结点 \(val) 后，AVL 树为")
+        print("\n插入节点 \(val) 后，AVL 树为")
         PrintUtil.printTree(root: tree.root)
     }
 
     static func testRemove(tree: AVLTree, val: Int) {
         tree.remove(val: val)
-        print("\n删除结点 \(val) 后，AVL 树为")
+        print("\n删除节点 \(val) 后，AVL 树为")
         PrintUtil.printTree(root: tree.root)
     }
 
@@ -213,8 +213,8 @@ enum _AVLTree {
         /* 初始化空 AVL 树 */
         let avlTree = AVLTree()
 
-        /* 插入结点 */
-        // 请关注插入结点后，AVL 树是如何保持平衡的
+        /* 插入节点 */
+        // 请关注插入节点后，AVL 树是如何保持平衡的
         testInsert(tree: avlTree, val: 1)
         testInsert(tree: avlTree, val: 2)
         testInsert(tree: avlTree, val: 3)
@@ -226,17 +226,17 @@ enum _AVLTree {
         testInsert(tree: avlTree, val: 10)
         testInsert(tree: avlTree, val: 6)
 
-        /* 插入重复结点 */
+        /* 插入重复节点 */
         testInsert(tree: avlTree, val: 7)
 
-        /* 删除结点 */
-        // 请关注删除结点后，AVL 树是如何保持平衡的
-        testRemove(tree: avlTree, val: 8) // 删除度为 0 的结点
-        testRemove(tree: avlTree, val: 5) // 删除度为 1 的结点
-        testRemove(tree: avlTree, val: 4) // 删除度为 2 的结点
+        /* 删除节点 */
+        // 请关注删除节点后，AVL 树是如何保持平衡的
+        testRemove(tree: avlTree, val: 8) // 删除度为 0 的节点
+        testRemove(tree: avlTree, val: 5) // 删除度为 1 的节点
+        testRemove(tree: avlTree, val: 4) // 删除度为 2 的节点
 
-        /* 查询结点 */
+        /* 查询节点 */
         let node = avlTree.search(val: 7)
-        print("\n查找到的结点对象为 \(node!)，结点值 = \(node!.val)")
+        print("\n查找到的节点对象为 \(node!)，节点值 = \(node!.val)")
     }
 }

codes/swift/chapter_tree/binary_search_tree.swift

@@ -15,7 +15,7 @@ class BinarySearchTree {
         root = buildTree(nums: nums, i: 0, j: nums.count - 1) // 构建二叉搜索树
     }
 
-    /* 获取二叉树根结点 */
+    /* 获取二叉树根节点 */
     func getRoot() -> TreeNode? {
         root
     }
@@ -25,7 +25,7 @@ class BinarySearchTree {
         if i > j {
             return nil
         }
-        // 将数组中间结点作为根结点
+        // 将数组中间节点作为根节点
         let mid = (i + j) / 2
         let root = TreeNode(x: nums[mid])
         // 递归建立左子树和右子树
@@ -34,29 +34,29 @@ class BinarySearchTree {
         return root
     }
 
-    /* 查找结点 */
+    /* 查找节点 */
     func search(num: Int) -> TreeNode? {
         var cur = root
-        // 循环查找，越过叶结点后跳出
+        // 循环查找，越过叶节点后跳出
         while cur != nil {
-            // 目标结点在 cur 的右子树中
+            // 目标节点在 cur 的右子树中
             if cur!.val < num {
                 cur = cur?.right
             }
-            // 目标结点在 cur 的左子树中
+            // 目标节点在 cur 的左子树中
             else if cur!.val > num {
                 cur = cur?.left
             }
-            // 找到目标结点，跳出循环
+            // 找到目标节点，跳出循环
             else {
                 break
             }
         }
-        // 返回目标结点
+        // 返回目标节点
         return cur
     }
 
-    /* 插入结点 */
+    /* 插入节点 */
     func insert(num: Int) -> TreeNode? {
         // 若树为空，直接提前返回
         if root == nil {
@@ -64,9 +64,9 @@ class BinarySearchTree {
         }
         var cur = root
         var pre: TreeNode?
-        // 循环查找，越过叶结点后跳出
+        // 循环查找，越过叶节点后跳出
         while cur != nil {
-            // 找到重复结点，直接返回
+            // 找到重复节点，直接返回
             if cur!.val == num {
                 return nil
             }
@@ -80,7 +80,7 @@ class BinarySearchTree {
                 cur = cur?.left
             }
         }
-        // 插入结点 val
+        // 插入节点 val
         let node = TreeNode(x: num)
         if pre!.val < num {
             pre?.right = node
@@ -90,7 +90,7 @@ class BinarySearchTree {
         return node
     }
 
-    /* 删除结点 */
+    /* 删除节点 */
     @discardableResult
     func remove(num: Int) -> TreeNode? {
         // 若树为空，直接提前返回
@@ -99,43 +99,43 @@ class BinarySearchTree {
         }
         var cur = root
         var pre: TreeNode?
-        // 循环查找，越过叶结点后跳出
+        // 循环查找，越过叶节点后跳出
         while cur != nil {
-            // 找到待删除结点，跳出循环
+            // 找到待删除节点，跳出循环
             if cur!.val == num {
                 break
             }
             pre = cur
-            // 待删除结点在 cur 的右子树中
+            // 待删除节点在 cur 的右子树中
             if cur!.val < num {
                 cur = cur?.right
             }
-            // 待删除结点在 cur 的左子树中
+            // 待删除节点在 cur 的左子树中
             else {
                 cur = cur?.left
             }
         }
-        // 若无待删除结点，则直接返回
+        // 若无待删除节点，则直接返回
         if cur == nil {
             return nil
         }
-        // 子结点数量 = 0 or 1
+        // 子节点数量 = 0 or 1
         if cur?.left == nil || cur?.right == nil {
-            // 当子结点数量 = 0 / 1 时， child = null / 该子结点
+            // 当子节点数量 = 0 / 1 时， child = null / 该子节点
             let child = cur?.left != nil ? cur?.left : cur?.right
-            // 删除结点 cur
+            // 删除节点 cur
             if pre?.left === cur {
                 pre?.left = child
             } else {
                 pre?.right = child
             }
         }
-        // 子结点数量 = 2
+        // 子节点数量 = 2
         else {
-            // 获取中序遍历中 cur 的下一个结点
+            // 获取中序遍历中 cur 的下一个节点
             let nex = getInOrderNext(root: cur?.right)
             let tmp = nex!.val
-            // 递归删除结点 nex
+            // 递归删除节点 nex
             remove(num: nex!.val)
             // 将 nex 的值复制给 cur
             cur?.val = tmp
@@ -143,13 +143,13 @@ class BinarySearchTree {
         return cur
     }
 
-    /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+    /* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
     func getInOrderNext(root: TreeNode?) -> TreeNode? {
         var root = root
         if root == nil {
             return root
         }
-        // 循环访问左子结点，直到叶结点时为最小结点，跳出
+        // 循环访问左子节点，直到叶节点时为最小节点，跳出
         while root?.left != nil {
             root = root?.left
         }
@@ -167,24 +167,24 @@ enum _BinarySearchTree {
         print("\n初始化的二叉树为\n")
         PrintUtil.printTree(root: bst.getRoot())
 
-        /* 查找结点 */
+        /* 查找节点 */
         var node = bst.search(num: 7)
-        print("\n查找到的结点对象为 \(node!)，结点值 = \(node!.val)")
+        print("\n查找到的节点对象为 \(node!)，节点值 = \(node!.val)")
 
-        /* 插入结点 */
+        /* 插入节点 */
         node = bst.insert(num: 16)
-        print("\n插入结点 16 后，二叉树为\n")
+        print("\n插入节点 16 后，二叉树为\n")
         PrintUtil.printTree(root: bst.getRoot())
 
-        /* 删除结点 */
+        /* 删除节点 */
         bst.remove(num: 1)
-        print("\n删除结点 1 后，二叉树为\n")
+        print("\n删除节点 1 后，二叉树为\n")
         PrintUtil.printTree(root: bst.getRoot())
         bst.remove(num: 2)
-        print("\n删除结点 2 后，二叉树为\n")
+        print("\n删除节点 2 后，二叉树为\n")
         PrintUtil.printTree(root: bst.getRoot())
         bst.remove(num: 4)
-        print("\n删除结点 4 后，二叉树为\n")
+        print("\n删除节点 4 后，二叉树为\n")
         PrintUtil.printTree(root: bst.getRoot())
     }
 }

codes/swift/chapter_tree/binary_tree.swift

@@ -11,7 +11,7 @@ enum BinaryTree {
     /* Driver Code */
     static func main() {
         /* 初始化二叉树 */
-        // 初始化结点
+        // 初始化节点
         let n1 = TreeNode(x: 1)
         let n2 = TreeNode(x: 2)
         let n3 = TreeNode(x: 3)
@@ -25,16 +25,16 @@ enum BinaryTree {
         print("\n初始化二叉树\n")
         PrintUtil.printTree(root: n1)
 
-        /* 插入与删除结点 */
+        /* 插入与删除节点 */
         let P = TreeNode(x: 0)
-        // 在 n1 -> n2 中间插入结点 P
+        // 在 n1 -> n2 中间插入节点 P
         n1.left = P
         P.left = n2
-        print("\n插入结点 P 后\n")
+        print("\n插入节点 P 后\n")
         PrintUtil.printTree(root: n1)
-        // 删除结点 P
+        // 删除节点 P
         n1.left = n2
-        print("\n删除结点 P 后\n")
+        print("\n删除节点 P 后\n")
         PrintUtil.printTree(root: n1)
     }
 }

codes/swift/chapter_tree/binary_tree_bfs.swift

@@ -8,18 +8,18 @@ import utils
 
 /* 层序遍历 */
 func levelOrder(root: TreeNode) -> [Int] {
-    // 初始化队列，加入根结点
+    // 初始化队列，加入根节点
     var queue: [TreeNode] = [root]
     // 初始化一个列表，用于保存遍历序列
     var list: [Int] = []
     while !queue.isEmpty {
         let node = queue.removeFirst() // 队列出队
-        list.append(node.val) // 保存结点值
+        list.append(node.val) // 保存节点值
         if let left = node.left {
-            queue.append(left) // 左子结点入队
+            queue.append(left) // 左子节点入队
         }
         if let right = node.right {
-            queue.append(right) // 右子结点入队
+            queue.append(right) // 右子节点入队
         }
     }
     return list
@@ -37,6 +37,6 @@ enum BinaryTreeBFS {
 
         /* 层序遍历 */
         let list = levelOrder(root: node)
-        print("\n层序遍历的结点打印序列 = \(list)")
+        print("\n层序遍历的节点打印序列 = \(list)")
     }
 }

codes/swift/chapter_tree/binary_tree_dfs.swift

@@ -14,7 +14,7 @@ func preOrder(root: TreeNode?) {
     guard let root = root else {
         return
     }
-    // 访问优先级：根结点 -> 左子树 -> 右子树
+    // 访问优先级：根节点 -> 左子树 -> 右子树
     list.append(root.val)
     preOrder(root: root.left)
     preOrder(root: root.right)
@@ -25,7 +25,7 @@ func inOrder(root: TreeNode?) {
     guard let root = root else {
         return
     }
-    // 访问优先级：左子树 -> 根结点 -> 右子树
+    // 访问优先级：左子树 -> 根节点 -> 右子树
     inOrder(root: root.left)
     list.append(root.val)
     inOrder(root: root.right)
@@ -36,7 +36,7 @@ func postOrder(root: TreeNode?) {
     guard let root = root else {
         return
     }
-    // 访问优先级：左子树 -> 右子树 -> 根结点
+    // 访问优先级：左子树 -> 右子树 -> 根节点
     postOrder(root: root.left)
     postOrder(root: root.right)
     list.append(root.val)
@@ -55,16 +55,16 @@ enum BinaryTreeDFS {
         /* 前序遍历 */
         list.removeAll()
         preOrder(root: root)
-        print("\n前序遍历的结点打印序列 = \(list)")
+        print("\n前序遍历的节点打印序列 = \(list)")
 
         /* 中序遍历 */
         list.removeAll()
         inOrder(root: root)
-        print("\n中序遍历的结点打印序列 = \(list)")
+        print("\n中序遍历的节点打印序列 = \(list)")
 
         /* 后序遍历 */
         list.removeAll()
         postOrder(root: root)
-        print("\n后序遍历的结点打印序列 = \(list)")
+        print("\n后序遍历的节点打印序列 = \(list)")
     }
 }