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

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

* Update mindmap

* Reduce the size of the mindmap.png

codes/go/chapter_tree/avl_tree.go

@@ -8,7 +8,7 @@ import . "github.com/krahets/hello-algo/pkg"
 
 /* AVL 树 */
 type aVLTree struct {
-	// 根结点
+	// 根节点
 	root *TreeNode
 }
 
@@ -16,20 +16,20 @@ func newAVLTree() *aVLTree {
 	return &aVLTree{root: nil}
 }
 
-/* 获取结点高度 */
+/* 获取节点高度 */
 func (t *aVLTree) height(node *TreeNode) int {
-	// 空结点高度为 -1 ，叶结点高度为 0
+	// 空节点高度为 -1 ，叶节点高度为 0
 	if node != nil {
 		return node.Height
 	}
 	return -1
 }
 
-/* 更新结点高度 */
+/* 更新节点高度 */
 func (t *aVLTree) updateHeight(node *TreeNode) {
 	lh := t.height(node.Left)
 	rh := t.height(node.Right)
-	// 结点高度等于最高子树高度 + 1
+	// 节点高度等于最高子树高度 + 1
 	if lh > rh {
 		node.Height = lh + 1
 	} else {
@@ -39,11 +39,11 @@ func (t *aVLTree) updateHeight(node *TreeNode) {
 
 /* 获取平衡因子 */
 func (t *aVLTree) balanceFactor(node *TreeNode) int {
-	// 空结点平衡因子为 0
+	// 空节点平衡因子为 0
 	if node == nil {
 		return 0
 	}
-	// 结点平衡因子 = 左子树高度 - 右子树高度
+	// 节点平衡因子 = 左子树高度 - 右子树高度
 	return t.height(node.Left) - t.height(node.Right)
 }
 
@@ -54,10 +54,10 @@ func (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {
 	// 以 child 为原点，将 node 向右旋转
 	child.Right = node
 	node.Left = grandChild
-	// 更新结点高度
+	// 更新节点高度
 	t.updateHeight(node)
 	t.updateHeight(child)
-	// 返回旋转后子树的根结点
+	// 返回旋转后子树的根节点
 	return child
 }
 
@@ -68,16 +68,16 @@ func (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {
 	// 以 child 为原点，将 node 向左旋转
 	child.Left = node
 	node.Right = grandChild
-	// 更新结点高度
+	// 更新节点高度
 	t.updateHeight(node)
 	t.updateHeight(child)
-	// 返回旋转后子树的根结点
+	// 返回旋转后子树的根节点
 	return child
 }
 
 /* 执行旋转操作，使该子树重新恢复平衡 */
 func (t *aVLTree) rotate(node *TreeNode) *TreeNode {
-	// 获取结点 node 的平衡因子
+	// 获取节点 node 的平衡因子
 	// Go 推荐短变量，这里 bf 指代 t.balanceFactor
 	bf := t.balanceFactor(node)
 	// 左偏树
@@ -106,46 +106,46 @@ func (t *aVLTree) rotate(node *TreeNode) *TreeNode {
 	return node
 }
 
-/* 插入结点 */
+/* 插入节点 */
 func (t *aVLTree) insert(val int) *TreeNode {
 	t.root = t.insertHelper(t.root, val)
 	return t.root
 }
 
-/* 递归插入结点（辅助方法） */
+/* 递归插入节点（辅助方法） */
 func (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {
 	if node == nil {
 		return NewTreeNode(val)
 	}
-	/* 1. 查找插入位置，并插入结点 */
+	/* 1. 查找插入位置，并插入节点 */
 	if val < node.Val {
 		node.Left = t.insertHelper(node.Left, val)
 	} else if val > node.Val {
 		node.Right = t.insertHelper(node.Right, val)
 	} else {
-		// 重复结点不插入，直接返回
+		// 重复节点不插入，直接返回
 		return node
 	}
-	// 更新结点高度
+	// 更新节点高度
 	t.updateHeight(node)
 	/* 2. 执行旋转操作，使该子树重新恢复平衡 */
 	node = t.rotate(node)
-	// 返回子树的根结点
+	// 返回子树的根节点
 	return node
 }
 
-/* 删除结点 */
+/* 删除节点 */
 func (t *aVLTree) remove(val int) *TreeNode {
 	root := t.removeHelper(t.root, val)
 	return root
 }
 
-/* 递归删除结点（辅助方法） */
+/* 递归删除节点（辅助方法） */
 func (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {
 	if node == nil {
 		return nil
 	}
-	/* 1. 查找结点，并删除之 */
+	/* 1. 查找节点，并删除之 */
 	if val < node.Val {
 		node.Left = t.removeHelper(node.Left, val)
 	} else if val > node.Val {
@@ -156,56 +156,56 @@ func (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {
 			if node.Right != nil {
 				child = node.Right
 			}
-			// 子结点数量 = 0 ，直接删除 node 并返回
+			// 子节点数量 = 0 ，直接删除 node 并返回
 			if child == nil {
 				return nil
 			} else {
-				// 子结点数量 = 1 ，直接删除 node
+				// 子节点数量 = 1 ，直接删除 node
 				node = child
 			}
 		} else {
-			// 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+			// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
 			temp := t.getInOrderNext(node.Right)
 			node.Right = t.removeHelper(node.Right, temp.Val)
 			node.Val = temp.Val
 		}
 	}
-	// 更新结点高度
+	// 更新节点高度
 	t.updateHeight(node)
 	/* 2. 执行旋转操作，使该子树重新恢复平衡 */
 	node = t.rotate(node)
-	// 返回子树的根结点
+	// 返回子树的根节点
 	return node
 }
 
-/* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
 func (t *aVLTree) getInOrderNext(node *TreeNode) *TreeNode {
 	if node == nil {
 		return node
 	}
-	// 循环访问左子结点，直到叶结点时为最小结点，跳出
+	// 循环访问左子节点，直到叶节点时为最小节点，跳出
 	for node.Left != nil {
 		node = node.Left
 	}
 	return node
 }
 
-/* 查找结点 */
+/* 查找节点 */
 func (t *aVLTree) search(val int) *TreeNode {
 	cur := t.root
-	// 循环查找，越过叶结点后跳出
+	// 循环查找，越过叶节点后跳出
 	for cur != nil {
 		if cur.Val < val {
-			// 目标结点在 cur 的右子树中
+			// 目标节点在 cur 的右子树中
 			cur = cur.Right
 		} else if cur.Val > val {
-			// 目标结点在 cur 的左子树中
+			// 目标节点在 cur 的左子树中
 			cur = cur.Left
 		} else {
-			// 找到目标结点，跳出循环
+			// 找到目标节点，跳出循环
 			break
 		}
 	}
-	// 返回目标结点
+	// 返回目标节点
 	return cur
 }

codes/go/chapter_tree/avl_tree_test.go

@@ -14,8 +14,8 @@ import (
 func TestAVLTree(t *testing.T) {
 	/* 初始化空 AVL 树 */
 	tree := newAVLTree()
-	/* 插入结点 */
-	// 请关注插入结点后，AVL 树是如何保持平衡的
+	/* 插入节点 */
+	// 请关注插入节点后，AVL 树是如何保持平衡的
 	testInsert(tree, 1)
 	testInsert(tree, 2)
 	testInsert(tree, 3)
@@ -27,28 +27,28 @@ func TestAVLTree(t *testing.T) {
 	testInsert(tree, 10)
 	testInsert(tree, 6)
 
-	/* 插入重复结点 */
+	/* 插入重复节点 */
 	testInsert(tree, 7)
 
-	/* 删除结点 */
-	// 请关注删除结点后，AVL 树是如何保持平衡的
-	testRemove(tree, 8) // 删除度为 0 的结点
-	testRemove(tree, 5) // 删除度为 1 的结点
-	testRemove(tree, 4) // 删除度为 2 的结点
+	/* 删除节点 */
+	// 请关注删除节点后，AVL 树是如何保持平衡的
+	testRemove(tree, 8) // 删除度为 0 的节点
+	testRemove(tree, 5) // 删除度为 1 的节点
+	testRemove(tree, 4) // 删除度为 2 的节点
 
-	/* 查询结点 */
+	/* 查询节点 */
 	node := tree.search(7)
-	fmt.Printf("\n查找到的结点对象为 %#v ，结点值 = %d \n", node, node.Val)
+	fmt.Printf("\n查找到的节点对象为 %#v ，节点值 = %d \n", node, node.Val)
 }
 
 func testInsert(tree *aVLTree, val int) {
 	tree.insert(val)
-	fmt.Printf("\n插入结点 %d 后，AVL 树为 \n", val)
+	fmt.Printf("\n插入节点 %d 后，AVL 树为 \n", val)
 	PrintTree(tree.root)
 }
 
 func testRemove(tree *aVLTree, val int) {
 	tree.remove(val)
-	fmt.Printf("\n删除结点 %d 后，AVL 树为 \n", val)
+	fmt.Printf("\n删除节点 %d 后，AVL 树为 \n", val)
 	PrintTree(tree.root)
 }

codes/go/chapter_tree/binary_search_tree.go

@@ -28,7 +28,7 @@ func (bst *binarySearchTree) buildTree(nums []int, left, right int) *TreeNode {
 	if left > right {
 		return nil
 	}
-	// 将数组中间结点作为根结点
+	// 将数组中间节点作为根节点
 	middle := left + (right-left)>>1
 	root := NewTreeNode(nums[middle])
 	// 递归构建左子树和右子树
@@ -37,53 +37,53 @@ func (bst *binarySearchTree) buildTree(nums []int, left, right int) *TreeNode {
 	return root
 }
 
-/* 获取根结点 */
+/* 获取根节点 */
 func (bst *binarySearchTree) getRoot() *TreeNode {
 	return bst.root
 }
 
-/* 获取中序遍历的下一个结点（仅适用于 root 有左子结点的情况） */
+/* 获取中序遍历的下一个节点（仅适用于 root 有左子节点的情况） */
 func (bst *binarySearchTree) getInOrderNext(node *TreeNode) *TreeNode {
 	if node == nil {
 		return node
 	}
-	// 循环访问左子结点，直到叶结点时为最小结点，跳出
+	// 循环访问左子节点，直到叶节点时为最小节点，跳出
 	for node.Left != nil {
 		node = node.Left
 	}
 	return node
 }
 
-/* 查找结点 */
+/* 查找节点 */
 func (bst *binarySearchTree) search(num int) *TreeNode {
 	node := bst.root
-	// 循环查找，越过叶结点后跳出
+	// 循环查找，越过叶节点后跳出
 	for node != nil {
 		if node.Val < num {
-			// 目标结点在 cur 的右子树中
+			// 目标节点在 cur 的右子树中
 			node = node.Right
 		} else if node.Val > num {
-			// 目标结点在 cur 的左子树中
+			// 目标节点在 cur 的左子树中
 			node = node.Left
 		} else {
-			// 找到目标结点，跳出循环
+			// 找到目标节点，跳出循环
 			break
 		}
 	}
-	// 返回目标结点
+	// 返回目标节点
 	return node
 }
 
-/* 插入结点 */
+/* 插入节点 */
 func (bst *binarySearchTree) insert(num int) *TreeNode {
 	cur := bst.root
 	// 若树为空，直接提前返回
 	if cur == nil {
 		return nil
 	}
-	// 待插入结点之前的结点位置
+	// 待插入节点之前的节点位置
 	var pre *TreeNode = nil
-	// 循环查找，越过叶结点后跳出
+	// 循环查找，越过叶节点后跳出
 	for cur != nil {
 		if cur.Val == num {
 			return nil
@@ -95,7 +95,7 @@ func (bst *binarySearchTree) insert(num int) *TreeNode {
 			cur = cur.Left
 		}
 	}
-	// 插入结点
+	// 插入节点
 	node := NewTreeNode(num)
 	if pre.Val < num {
 		pre.Right = node
@@ -105,54 +105,54 @@ func (bst *binarySearchTree) insert(num int) *TreeNode {
 	return cur
 }
 
-/* 删除结点 */
+/* 删除节点 */
 func (bst *binarySearchTree) remove(num int) *TreeNode {
 	cur := bst.root
 	// 若树为空，直接提前返回
 	if cur == nil {
 		return nil
 	}
-	// 待删除结点之前的结点位置
+	// 待删除节点之前的节点位置
 	var pre *TreeNode = nil
-	// 循环查找，越过叶结点后跳出
+	// 循环查找，越过叶节点后跳出
 	for cur != nil {
 		if cur.Val == num {
 			break
 		}
 		pre = cur
 		if cur.Val < num {
-			// 待删除结点在右子树中
+			// 待删除节点在右子树中
 			cur = cur.Right
 		} else {
-			// 待删除结点在左子树中
+			// 待删除节点在左子树中
 			cur = cur.Left
 		}
 	}
-	// 若无待删除结点，则直接返回
+	// 若无待删除节点，则直接返回
 	if cur == nil {
 		return nil
 	}
-	// 子结点数为 0 或 1
+	// 子节点数为 0 或 1
 	if cur.Left == nil || cur.Right == nil {
 		var child *TreeNode = nil
-		// 取出待删除结点的子结点
+		// 取出待删除节点的子节点
 		if cur.Left != nil {
 			child = cur.Left
 		} else {
 			child = cur.Right
 		}
-		// 将子结点替换为待删除结点
+		// 将子节点替换为待删除节点
 		if pre.Left == cur {
 			pre.Left = child
 		} else {
 			pre.Right = child
 		}
-		// 子结点数为 2
+		// 子节点数为 2
 	} else {
-		// 获取中序遍历中待删除结点 cur 的下一个结点
+		// 获取中序遍历中待删除节点 cur 的下一个节点
 		next := bst.getInOrderNext(cur)
 		temp := next.Val
-		// 递归删除结点 next
+		// 递归删除节点 next
 		bst.remove(next.Val)
 		// 将 next 的值复制给 cur
 		cur.Val = temp

codes/go/chapter_tree/binary_search_tree_test.go

@@ -15,27 +15,27 @@ func TestBinarySearchTree(t *testing.T) {
 	fmt.Println("\n初始化的二叉树为:")
 	bst.print()
 
-	// 获取根结点
+	// 获取根节点
 	node := bst.getRoot()
-	fmt.Println("\n二叉树的根结点为:", node.Val)
+	fmt.Println("\n二叉树的根节点为:", node.Val)
 
-	// 查找结点
+	// 查找节点
 	node = bst.search(7)
-	fmt.Println("查找到的结点对象为", node, "，结点值 =", node.Val)
+	fmt.Println("查找到的节点对象为", node, "，节点值 =", node.Val)
 
-	// 插入结点
+	// 插入节点
 	node = bst.insert(16)
-	fmt.Println("\n插入结点后 16 的二叉树为:")
+	fmt.Println("\n插入节点后 16 的二叉树为:")
 	bst.print()
 
-	// 删除结点
+	// 删除节点
 	bst.remove(1)
-	fmt.Println("\n删除结点 1 后的二叉树为:")
+	fmt.Println("\n删除节点 1 后的二叉树为:")
 	bst.print()
 	bst.remove(2)
-	fmt.Println("\n删除结点 2 后的二叉树为:")
+	fmt.Println("\n删除节点 2 后的二叉树为:")
 	bst.print()
 	bst.remove(4)
-	fmt.Println("\n删除结点 4 后的二叉树为:")
+	fmt.Println("\n删除节点 4 后的二叉树为:")
 	bst.print()
 }

codes/go/chapter_tree/binary_tree_bfs.go

@@ -12,7 +12,7 @@ import (
 
 /* 层序遍历 */
 func levelOrder(root *TreeNode) []int {
-	// 初始化队列，加入根结点
+	// 初始化队列，加入根节点
 	queue := list.New()
 	queue.PushBack(root)
 	// 初始化一个切片，用于保存遍历序列
@@ -20,14 +20,14 @@ func levelOrder(root *TreeNode) []int {
 	for queue.Len() > 0 {
 		// 队列出队
 		node := queue.Remove(queue.Front()).(*TreeNode)
-		// 保存结点值
+		// 保存节点值
 		nums = append(nums, node.Val)
 		if node.Left != nil {
-			// 左子结点入队
+			// 左子节点入队
 			queue.PushBack(node.Left)
 		}
 		if node.Right != nil {
-			// 右子结点入队
+			// 右子节点入队
 			queue.PushBack(node.Right)
 		}
 	}

codes/go/chapter_tree/binary_tree_bfs_test.go

@@ -20,5 +20,5 @@ func TestLevelOrder(t *testing.T) {
 
 	// 层序遍历
 	nums := levelOrder(root)
-	fmt.Println("\n层序遍历的结点打印序列 =", nums)
+	fmt.Println("\n层序遍历的节点打印序列 =", nums)
 }

codes/go/chapter_tree/binary_tree_dfs.go

@@ -15,7 +15,7 @@ func preOrder(node *TreeNode) {
 	if node == nil {
 		return
 	}
-	// 访问优先级：根结点 -> 左子树 -> 右子树
+	// 访问优先级：根节点 -> 左子树 -> 右子树
 	nums = append(nums, node.Val)
 	preOrder(node.Left)
 	preOrder(node.Right)
@@ -26,7 +26,7 @@ func inOrder(node *TreeNode) {
 	if node == nil {
 		return
 	}
-	// 访问优先级：左子树 -> 根结点 -> 右子树
+	// 访问优先级：左子树 -> 根节点 -> 右子树
 	inOrder(node.Left)
 	nums = append(nums, node.Val)
 	inOrder(node.Right)
@@ -37,7 +37,7 @@ func postOrder(node *TreeNode) {
 	if node == nil {
 		return
 	}
-	// 访问优先级：左子树 -> 右子树 -> 根结点
+	// 访问优先级：左子树 -> 右子树 -> 根节点
 	postOrder(node.Left)
 	postOrder(node.Right)
 	nums = append(nums, node.Val)

codes/go/chapter_tree/binary_tree_dfs_test.go

@@ -21,15 +21,15 @@ func TestPreInPostOrderTraversal(t *testing.T) {
 	// 前序遍历
 	nums = nil
 	preOrder(root)
-	fmt.Println("\n前序遍历的结点打印序列 =", nums)
+	fmt.Println("\n前序遍历的节点打印序列 =", nums)
 
 	// 中序遍历
 	nums = nil
 	inOrder(root)
-	fmt.Println("\n中序遍历的结点打印序列 =", nums)
+	fmt.Println("\n中序遍历的节点打印序列 =", nums)
 
 	// 后序遍历
 	nums = nil
 	postOrder(root)
-	fmt.Println("\n后序遍历的结点打印序列 =", nums)
+	fmt.Println("\n后序遍历的节点打印序列 =", nums)
 }

codes/go/chapter_tree/binary_tree_test.go

@@ -13,7 +13,7 @@ import (
 
 func TestBinaryTree(t *testing.T) {
 	/* 初始化二叉树 */
-	// 初始化结点
+	// 初始化节点
 	n1 := NewTreeNode(1)
 	n2 := NewTreeNode(2)
 	n3 := NewTreeNode(3)
@@ -27,15 +27,15 @@ func TestBinaryTree(t *testing.T) {
 	fmt.Println("初始化二叉树")
 	PrintTree(n1)
 
-	/* 插入与删除结点 */
-	// 插入结点
+	/* 插入与删除节点 */
+	// 插入节点
 	p := NewTreeNode(0)
 	n1.Left = p
 	p.Left = n2
-	fmt.Println("插入结点 P 后")
+	fmt.Println("插入节点 P 后")
 	PrintTree(n1)
-	// 删除结点
+	// 删除节点
 	n1.Left = n2
-	fmt.Println("删除结点 P 后")
+	fmt.Println("删除节点 P 后")
 	PrintTree(n1)
 }