Fix the return type of binary search tree and avl tree

codes/go/chapter_tree/avl_tree.go

@@ -107,9 +107,8 @@ func (t *aVLTree) rotate(node *TreeNode) *TreeNode {
 }
 
 /* 插入节点 */
-func (t *aVLTree) insert(val int) *TreeNode {
+func (t *aVLTree) insert(val int) {
 	t.root = t.insertHelper(t.root, val)
-	return t.root
 }
 
 /* 递归插入节点（辅助方法） */
@@ -135,9 +134,8 @@ func (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {
 }
 
 /* 删除节点 */
-func (t *aVLTree) remove(val int) *TreeNode {
-	root := t.removeHelper(t.root, val)
-	return root
+func (t *aVLTree) remove(val int) {
+	t.root = t.removeHelper(t.root, val)
 }
 
 /* 递归删除节点（辅助方法） */
@@ -156,8 +154,8 @@ func (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {
 			if node.Right != nil {
 				child = node.Right
 			}
-			// 子节点数量 = 0 ，直接删除 node 并返回
 			if child == nil {
+				// 子节点数量 = 0 ，直接删除 node 并返回
 				return nil
 			} else {
 				// 子节点数量 = 1 ，直接删除 node
@@ -165,7 +163,10 @@ func (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {
 			}
 		} else {
 			// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
-			temp := t.getInOrderNext(node.Right)
+			temp := node.Right
+			for temp.Left != nil {
+				temp = temp.Left
+			}
 			node.Right = t.removeHelper(node.Right, temp.Val)
 			node.Val = temp.Val
 		}
@@ -178,18 +179,6 @@ func (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {
 	return node
 }
 
-/* 获取中序遍历中的下一个节点（仅适用于 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

codes/go/chapter_tree/binary_search_tree.go

@@ -42,18 +42,6 @@ func (bst *binarySearchTree) getRoot() *TreeNode {
 	return bst.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
@@ -75,18 +63,18 @@ func (bst *binarySearchTree) search(num int) *TreeNode {
 }
 
 /* 插入节点 */
-func (bst *binarySearchTree) insert(num int) *TreeNode {
+func (bst *binarySearchTree) insert(num int) {
 	cur := bst.root
 	// 若树为空，直接提前返回
 	if cur == nil {
-		return nil
+		return
 	}
 	// 待插入节点之前的节点位置
 	var pre *TreeNode = nil
 	// 循环查找，越过叶节点后跳出
 	for cur != nil {
 		if cur.Val == num {
-			return nil
+			return
 		}
 		pre = cur
 		if cur.Val < num {
@@ -102,15 +90,14 @@ func (bst *binarySearchTree) insert(num int) *TreeNode {
 	} else {
 		pre.Left = node
 	}
-	return cur
 }
 
 /* 删除节点 */
-func (bst *binarySearchTree) remove(num int) *TreeNode {
+func (bst *binarySearchTree) remove(num int) {
 	cur := bst.root
 	// 若树为空，直接提前返回
 	if cur == nil {
-		return nil
+		return
 	}
 	// 待删除节点之前的节点位置
 	var pre *TreeNode = nil
@@ -130,7 +117,7 @@ func (bst *binarySearchTree) remove(num int) *TreeNode {
 	}
 	// 若无待删除节点，则直接返回
 	if cur == nil {
-		return nil
+		return
 	}
 	// 子节点数为 0 或 1
 	if cur.Left == nil || cur.Right == nil {
@@ -150,14 +137,15 @@ func (bst *binarySearchTree) remove(num int) *TreeNode {
 		// 子节点数为 2
 	} else {
 		// 获取中序遍历中待删除节点 cur 的下一个节点
-		next := bst.getInOrderNext(cur)
-		temp := next.Val
-		// 递归删除节点 next
-		bst.remove(next.Val)
-		// 将 next 的值复制给 cur
-		cur.Val = temp
+		tmp := cur.Right
+		for tmp.Left != nil {
+			tmp = tmp.Left
+		}
+		// 递归删除节点 tmp
+		bst.remove(tmp.Val)
+		// 用 tmp 覆盖 cur
+		cur.Val = tmp.Val
 	}
-	return cur
 }
 
 /* 打印二叉搜索树 */

codes/go/chapter_tree/binary_search_tree_test.go

@@ -24,7 +24,7 @@ func TestBinarySearchTree(t *testing.T) {
 	fmt.Println("查找到的节点对象为", node, "，节点值 =", node.Val)
 
 	// 插入节点
-	node = bst.insert(16)
+	bst.insert(16)
 	fmt.Println("\n插入节点后 16 的二叉树为:")
 	bst.print()