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

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

* Update mindmap

* Reduce the size of the mindmap.png

codes/go/chapter_array_and_linkedlist/linked_list.go

@@ -8,14 +8,14 @@ import (
 	. "github.com/krahets/hello-algo/pkg"
 )
 
-/* 在链表的结点 n0 之后插入结点 P */
+/* 在链表的节点 n0 之后插入节点 P */
 func insertNode(n0 *ListNode, P *ListNode) {
 	n1 := n0.Next
 	P.Next = n1
 	n0.Next = P
 }
 
-/* 删除链表的结点 n0 之后的首个结点 */
+/* 删除链表的节点 n0 之后的首个节点 */
 func removeNode(n0 *ListNode) {
 	if n0.Next == nil {
 		return
@@ -26,7 +26,7 @@ func removeNode(n0 *ListNode) {
 	n0.Next = n1
 }
 
-/* 访问链表中索引为 index 的结点 */
+/* 访问链表中索引为 index 的节点 */
 func access(head *ListNode, index int) *ListNode {
 	for i := 0; i < index; i++ {
 		if head == nil {
@@ -37,7 +37,7 @@ func access(head *ListNode, index int) *ListNode {
 	return head
 }
 
-/* 在链表中查找值为 target 的首个结点 */
+/* 在链表中查找值为 target 的首个节点 */
 func findNode(head *ListNode, target int) int {
 	index := 0
 	for head != nil {

codes/go/chapter_array_and_linkedlist/linked_list_test.go

@@ -13,7 +13,7 @@ import (
 
 func TestLinkedList(t *testing.T) {
 	/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
-	// 初始化各个结点
+	// 初始化各个节点
 	n0 := NewListNode(1)
 	n1 := NewListNode(3)
 	n2 := NewListNode(2)
@@ -28,21 +28,21 @@ func TestLinkedList(t *testing.T) {
 	fmt.Println("初始化的链表为")
 	PrintLinkedList(n0)
 
-	/* 插入结点 */
+	/* 插入节点 */
 	insertNode(n0, NewListNode(0))
-	fmt.Println("插入结点后的链表为")
+	fmt.Println("插入节点后的链表为")
 	PrintLinkedList(n0)
 
-	/* 删除结点 */
+	/* 删除节点 */
 	removeNode(n0)
-	fmt.Println("删除结点后的链表为")
+	fmt.Println("删除节点后的链表为")
 	PrintLinkedList(n0)
 
-	/* 访问结点 */
+	/* 访问节点 */
 	node := access(n0, 3)
-	fmt.Println("链表中索引 3 处的结点的值 =", node)
+	fmt.Println("链表中索引 3 处的节点的值 =", node)
 
-	/* 查找结点 */
+	/* 查找节点 */
 	index := findNode(n0, 2)
-	fmt.Println("链表中值为 2 的结点的索引 =", index)
+	fmt.Println("链表中值为 2 的节点的索引 =", index)
 }

codes/go/chapter_heap/my_heap.go

@@ -27,23 +27,23 @@ func newMaxHeap(nums []any) *maxHeap {
 	// 将列表元素原封不动添加进堆
 	h := &maxHeap{data: nums}
 	for i := len(h.data) - 1; i >= 0; i-- {
-		// 堆化除叶结点以外的其他所有结点
+		// 堆化除叶节点以外的其他所有节点
 		h.siftDown(i)
 	}
 	return h
 }
 
-/* 获取左子结点索引 */
+/* 获取左子节点索引 */
 func (h *maxHeap) left(i int) int {
 	return 2*i + 1
 }
 
-/* 获取右子结点索引 */
+/* 获取右子节点索引 */
 func (h *maxHeap) right(i int) int {
 	return 2*i + 2
 }
 
-/* 获取父结点索引 */
+/* 获取父节点索引 */
 func (h *maxHeap) parent(i int) int {
 	// 向下整除
 	return (i - 1) / 2
@@ -71,22 +71,22 @@ func (h *maxHeap) peek() any {
 
 /* 元素入堆 */
 func (h *maxHeap) push(val any) {
-	// 添加结点
+	// 添加节点
 	h.data = append(h.data, val)
 	// 从底至顶堆化
 	h.siftUp(len(h.data) - 1)
 }
 
-/* 从结点 i 开始，从底至顶堆化 */
+/* 从节点 i 开始，从底至顶堆化 */
 func (h *maxHeap) siftUp(i int) {
 	for true {
-		// 获取结点 i 的父结点
+		// 获取节点 i 的父节点
 		p := h.parent(i)
-		// 当“越过根结点”或“结点无需修复”时，结束堆化
+		// 当“越过根节点”或“节点无需修复”时，结束堆化
 		if p < 0 || h.data[i].(int) <= h.data[p].(int) {
 			break
 		}
-		// 交换两结点
+		// 交换两节点
 		h.swap(i, p)
 		// 循环向上堆化
 		i = p
@@ -100,9 +100,9 @@ func (h *maxHeap) pop() any {
 		fmt.Println("error")
 		return nil
 	}
-	// 交换根结点与最右叶结点（即交换首元素与尾元素）
+	// 交换根节点与最右叶节点（即交换首元素与尾元素）
 	h.swap(0, h.size()-1)
-	// 删除结点
+	// 删除节点
 	val := h.data[len(h.data)-1]
 	h.data = h.data[:len(h.data)-1]
 	// 从顶至底堆化
@@ -112,10 +112,10 @@ func (h *maxHeap) pop() any {
 	return val
 }
 
-/* 从结点 i 开始，从顶至底堆化 */
+/* 从节点 i 开始，从顶至底堆化 */
 func (h *maxHeap) siftDown(i int) {
 	for true {
-		// 判断结点 i, l, r 中值最大的结点，记为 max
+		// 判断节点 i, l, r 中值最大的节点，记为 max
 		l, r, max := h.left(i), h.right(i), i
 		if l < h.size() && h.data[l].(int) > h.data[max].(int) {
 			max = l
@@ -123,11 +123,11 @@ func (h *maxHeap) siftDown(i int) {
 		if r < h.size() && h.data[r].(int) > h.data[max].(int) {
 			max = r
 		}
-		// 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+		// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
 		if max == i {
 			break
 		}
-		// 交换两结点
+		// 交换两节点
 		h.swap(i, max)
 		// 循环向下堆化
 		i = max

codes/go/chapter_searching/hashing_search.go

@@ -19,7 +19,7 @@ func hashingSearchArray(m map[int]int, target int) int {
 
 /* 哈希查找（链表） */
 func hashingSearchLinkedList(m map[int]*ListNode, target int) *ListNode {
-	// 哈希表的 key: 目标结点值，value: 结点对象
+	// 哈希表的 key: 目标节点值，value: 节点对象
 	// 若哈希表中无此 key ，返回 nil
 	if node, ok := m[target]; ok {
 		return node

codes/go/chapter_searching/hashing_search_test.go

@@ -32,5 +32,5 @@ func TestHashingSearch(t *testing.T) {
 		head = head.Next
 	}
 	node := hashingSearchLinkedList(m1, target)
-	fmt.Println("目标结点值 3 的对应结点对象为 ", node)
+	fmt.Println("目标节点值 3 的对应节点对象为 ", node)
 }

codes/go/chapter_searching/linear_search.go

@@ -25,7 +25,7 @@ func linearSearchArray(nums []int, target int) int {
 func linearSearchLinkedList(node *ListNode, target int) *ListNode {
 	// 遍历链表
 	for node != nil {
-		// 找到目标结点，返回之
+		// 找到目标节点，返回之
 		if node.Val == target {
 			return node
 		}

codes/go/chapter_searching/linear_search_test.go

@@ -22,5 +22,5 @@ func TestLinearSearch(t *testing.T) {
 	// 在链表中执行线性查找
 	head := ArrayToLinkedList(nums)
 	node := linearSearchLinkedList(head, target)
-	fmt.Println("目标结点值 3 的对应结点对象为", node)
+	fmt.Println("目标节点值 3 的对应节点对象为", node)
 }

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

codes/go/pkg/tree_node.go

@@ -9,10 +9,10 @@ import (
 )
 
 type TreeNode struct {
-	Val    int       // 结点值
-	Height int       // 结点高度
-	Left   *TreeNode // 左子结点引用
-	Right  *TreeNode // 右子结点引用
+	Val    int       // 节点值
+	Height int       // 节点高度
+	Left   *TreeNode // 左子节点引用
+	Right  *TreeNode // 右子节点引用
 }
 
 func NewTreeNode(v int) *TreeNode {