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

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

* Update mindmap

* Reduce the size of the mindmap.png

codes/swift/chapter_array_and_linkedlist/linked_list.swift

@@ -6,14 +6,14 @@
 
 import utils
 
-/* 在链表的结点 n0 之后插入结点 P */
+/* 在链表的节点 n0 之后插入节点 P */
 func insert(n0: ListNode, P: ListNode) {
     let n1 = n0.next
     P.next = n1
     n0.next = P
 }
 
-/* 删除链表的结点 n0 之后的首个结点 */
+/* 删除链表的节点 n0 之后的首个节点 */
 func remove(n0: ListNode) {
     if n0.next == nil {
         return
@@ -25,7 +25,7 @@ func remove(n0: ListNode) {
     P?.next = nil
 }
 
-/* 访问链表中索引为 index 的结点 */
+/* 访问链表中索引为 index 的节点 */
 func access(head: ListNode, index: Int) -> ListNode? {
     var head: ListNode? = head
     for _ in 0 ..< index {
@@ -37,7 +37,7 @@ func access(head: ListNode, index: Int) -> ListNode? {
     return head
 }
 
-/* 在链表中查找值为 target 的首个结点 */
+/* 在链表中查找值为 target 的首个节点 */
 func find(head: ListNode, target: Int) -> Int {
     var head: ListNode? = head
     var index = 0
@@ -56,7 +56,7 @@ enum LinkedList {
     /* Driver Code */
     static func main() {
         /* 初始化链表 */
-        // 初始化各个结点
+        // 初始化各个节点
         let n0 = ListNode(x: 1)
         let n1 = ListNode(x: 3)
         let n2 = ListNode(x: 2)
@@ -70,22 +70,22 @@ enum LinkedList {
         print("初始化的链表为")
         PrintUtil.printLinkedList(head: n0)
 
-        /* 插入结点 */
+        /* 插入节点 */
         insert(n0: n0, P: ListNode(x: 0))
-        print("插入结点后的链表为")
+        print("插入节点后的链表为")
         PrintUtil.printLinkedList(head: n0)
 
-        /* 删除结点 */
+        /* 删除节点 */
         remove(n0: n0)
-        print("删除结点后的链表为")
+        print("删除节点后的链表为")
         PrintUtil.printLinkedList(head: n0)
 
-        /* 访问结点 */
+        /* 访问节点 */
         let node = access(head: n0, index: 3)
-        print("链表中索引 3 处的结点的值 = \(node!.val)")
+        print("链表中索引 3 处的节点的值 = \(node!.val)")
 
-        /* 查找结点 */
+        /* 查找节点 */
         let index = find(head: n0, target: 2)
-        print("链表中值为 2 的结点的索引 = \(index)")
+        print("链表中值为 2 的节点的索引 = \(index)")
     }
 }

codes/swift/chapter_heap/my_heap.swift

@@ -14,23 +14,23 @@ class MaxHeap {
     init(nums: [Int]) {
         // 将列表元素原封不动添加进堆
         maxHeap = nums
-        // 堆化除叶结点以外的其他所有结点
+        // 堆化除叶节点以外的其他所有节点
         for i in stride(from: parent(i: size() - 1), through: 0, by: -1) {
             siftDown(i: i)
         }
     }
 
-    /* 获取左子结点索引 */
+    /* 获取左子节点索引 */
     private func left(i: Int) -> Int {
         2 * i + 1
     }
 
-    /* 获取右子结点索引 */
+    /* 获取右子节点索引 */
     private func right(i: Int) -> Int {
         2 * i + 2
     }
 
-    /* 获取父结点索引 */
+    /* 获取父节点索引 */
     private func parent(i: Int) -> Int {
         (i - 1) / 2 // 向下整除
     }
@@ -57,23 +57,23 @@ class MaxHeap {
 
     /* 元素入堆 */
     func push(val: Int) {
-        // 添加结点
+        // 添加节点
         maxHeap.append(val)
         // 从底至顶堆化
         siftUp(i: size() - 1)
     }
 
-    /* 从结点 i 开始，从底至顶堆化 */
+    /* 从节点 i 开始，从底至顶堆化 */
     private func siftUp(i: Int) {
         var i = i
         while true {
-            // 获取结点 i 的父结点
+            // 获取节点 i 的父节点
             let p = parent(i: i)
-            // 当“越过根结点”或“结点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无需修复”时，结束堆化
             if p < 0 || maxHeap[i] <= maxHeap[p] {
                 break
             }
-            // 交换两结点
+            // 交换两节点
             swap(i: i, j: p)
             // 循环向上堆化
             i = p
@@ -86,9 +86,9 @@ class MaxHeap {
         if isEmpty() {
             fatalError("堆为空")
         }
-        // 交换根结点与最右叶结点（即交换首元素与尾元素）
+        // 交换根节点与最右叶节点（即交换首元素与尾元素）
         swap(i: 0, j: size() - 1)
-        // 删除结点
+        // 删除节点
         let val = maxHeap.remove(at: size() - 1)
         // 从顶至底堆化
         siftDown(i: 0)
@@ -96,11 +96,11 @@ class MaxHeap {
         return val
     }
 
-    /* 从结点 i 开始，从顶至底堆化 */
+    /* 从节点 i 开始，从顶至底堆化 */
     private func siftDown(i: Int) {
         var i = i
         while true {
-            // 判断结点 i, l, r 中值最大的结点，记为 ma
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
             let l = left(i: i)
             let r = right(i: i)
             var ma = i
@@ -110,11 +110,11 @@ class MaxHeap {
             if r < size(), maxHeap[r] > maxHeap[ma] {
                 ma = r
             }
-            // 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
             if ma == i {
                 break
             }
-            // 交换两结点
+            // 交换两节点
             swap(i: i, j: ma)
             // 循环向下堆化
             i = ma

codes/swift/chapter_searching/hashing_search.swift

@@ -15,7 +15,7 @@ func hashingSearchArray(map: [Int: Int], target: Int) -> Int {
 
 /* 哈希查找（链表） */
 func hashingSearchLinkedList(map: [Int: ListNode], target: Int) -> ListNode? {
-    // 哈希表的 key: 目标结点值，value: 结点对象
+    // 哈希表的 key: 目标节点值，value: 节点对象
     // 若哈希表中无此 key ，返回 null
     return map[target]
 }
@@ -41,10 +41,10 @@ enum HashingSearch {
         // 初始化哈希表
         var map1: [Int: ListNode] = [:]
         while head != nil {
-            map1[head!.val] = head! // key: 结点值，value: 结点
+            map1[head!.val] = head! // key: 节点值，value: 节点
             head = head?.next
         }
         let node = hashingSearchLinkedList(map: map1, target: target)
-        print("目标结点值 3 的对应结点对象为 \(node!)")
+        print("目标节点值 3 的对应节点对象为 \(node!)")
     }
 }

codes/swift/chapter_searching/linear_search.swift

@@ -24,13 +24,13 @@ func linearSearchLinkedList(head: ListNode?, target: Int) -> ListNode? {
     var head = head
     // 遍历链表
     while head != nil {
-        // 找到目标结点，返回之
+        // 找到目标节点，返回之
         if head?.val == target {
             return head
         }
         head = head?.next
     }
-    // 未找到目标结点，返回 null
+    // 未找到目标节点，返回 null
     return nil
 }
 
@@ -48,6 +48,6 @@ enum LinearSearch {
         /* 在链表中执行线性查找 */
         let head = ListNode.arrToLinkedList(arr: nums)
         let node = linearSearchLinkedList(head: head, target: target)
-        print("目标结点值 3 的对应结点对象为 \(node!)")
+        print("目标节点值 3 的对应节点对象为 \(node!)")
     }
 }

codes/swift/chapter_stack_and_queue/linkedlist_deque.swift

@@ -4,11 +4,11 @@
  * Author: nuomi1 (nuomi1@qq.com)
  */
 
-/* 双向链表结点 */
+/* 双向链表节点 */
 class ListNode {
-    var val: Int // 结点值
-    var next: ListNode? // 后继结点引用（指针）
-    var prev: ListNode? // 前驱结点引用（指针）
+    var val: Int // 节点值
+    var next: ListNode? // 后继节点引用（指针）
+    var prev: ListNode? // 前驱节点引用（指针）
 
     init(val: Int) {
         self.val = val
@@ -17,8 +17,8 @@ class ListNode {
 
 /* 基于双向链表实现的双向队列 */
 class LinkedListDeque {
-    private var front: ListNode? // 头结点 front
-    private var rear: ListNode? // 尾结点 rear
+    private var front: ListNode? // 头节点 front
+    private var rear: ListNode? // 尾节点 rear
     private var queSize: Int // 双向队列的长度
 
     init() {
@@ -48,14 +48,14 @@ class LinkedListDeque {
             // 将 node 添加至链表头部
             front?.prev = node
             node.next = front
-            front = node // 更新头结点
+            front = node // 更新头节点
         }
         // 队尾入队操作
         else {
             // 将 node 添加至链表尾部
             rear?.next = node
             node.prev = rear
-            rear = node // 更新尾结点
+            rear = node // 更新尾节点
         }
         queSize += 1 // 更新队列长度
     }
@@ -78,25 +78,25 @@ class LinkedListDeque {
         let val: Int
         // 队首出队操作
         if isFront {
-            val = front!.val // 暂存头结点值
-            // 删除头结点
+            val = front!.val // 暂存头节点值
+            // 删除头节点
             let fNext = front?.next
             if fNext != nil {
                 fNext?.prev = nil
                 front?.next = nil
             }
-            front = fNext // 更新头结点
+            front = fNext // 更新头节点
         }
         // 队尾出队操作
         else {
-            val = rear!.val // 暂存尾结点值
-            // 删除尾结点
+            val = rear!.val // 暂存尾节点值
+            // 删除尾节点
             let rPrev = rear?.prev
             if rPrev != nil {
                 rPrev?.next = nil
                 rear?.prev = nil
             }
-            rear = rPrev // 更新尾结点
+            rear = rPrev // 更新尾节点
         }
         queSize -= 1 // 更新队列长度
         return val

codes/swift/chapter_stack_and_queue/linkedlist_queue.swift

@@ -8,8 +8,8 @@ import utils
 
 /* 基于链表实现的队列 */
 class LinkedListQueue {
-    private var front: ListNode? // 头结点
-    private var rear: ListNode? // 尾结点
+    private var front: ListNode? // 头节点
+    private var rear: ListNode? // 尾节点
     private var _size = 0
 
     init() {}
@@ -26,14 +26,14 @@ class LinkedListQueue {
 
     /* 入队 */
     func push(num: Int) {
-        // 尾结点后添加 num
+        // 尾节点后添加 num
         let node = ListNode(x: num)
-        // 如果队列为空，则令头、尾结点都指向该结点
+        // 如果队列为空，则令头、尾节点都指向该节点
         if front == nil {
             front = node
             rear = node
         }
-        // 如果队列不为空，则将该结点添加到尾结点后
+        // 如果队列不为空，则将该节点添加到尾节点后
         else {
             rear?.next = node
             rear = node
@@ -45,7 +45,7 @@ class LinkedListQueue {
     @discardableResult
     func pop() -> Int {
         let num = peek()
-        // 删除头结点
+        // 删除头节点
         front = front?.next
         _size -= 1
         return num

codes/swift/chapter_stack_and_queue/linkedlist_stack.swift

@@ -8,7 +8,7 @@ import utils
 
 /* 基于链表实现的栈 */
 class LinkedListStack {
-    private var _peek: ListNode? // 将头结点作为栈顶
+    private var _peek: ListNode? // 将头节点作为栈顶
     private var _size = 0 // 栈的长度
 
     init() {}

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)")
     }
 }

codes/swift/utils/ListNode.swift

@@ -5,8 +5,8 @@
  */
 
 public class ListNode {
-    public var val: Int // 结点值
-    public var next: ListNode? // 后继结点引用
+    public var val: Int // 节点值
+    public var next: ListNode? // 后继节点引用
 
     public init(x: Int) {
         val = x

codes/swift/utils/TreeNode.swift

@@ -5,10 +5,10 @@
  */
 
 public class TreeNode {
-    public var val: Int // 结点值
-    public var height: Int // 结点高度
-    public var left: TreeNode? // 左子结点引用
-    public var right: TreeNode? // 右子结点引用
+    public var val: Int // 节点值
+    public var height: Int // 节点高度
+    public var left: TreeNode? // 左子节点引用
+    public var right: TreeNode? // 右子节点引用
 
     public init(x: Int) {
         val = x