Merge branch 'master' into binary_search_tree

codes/go/chapter_tree/avl_tree.go

@@ -0,0 +1,211 @@
+// File: avl_tree.go
+// Created Time: 2023-01-08
+// Author: Reanon (793584285@qq.com)
+
+package chapter_tree
+
+import . "github.com/krahets/hello-algo/pkg"
+
+/* AVL Tree*/
+type avlTree struct {
+	// 根节点
+	root *TreeNode
+}
+
+func newAVLTree() *avlTree {
+	return &avlTree{root: nil}
+}
+
+/* 获取结点高度 */
+func height(node *TreeNode) int {
+	// 空结点高度为 -1 ，叶结点高度为 0
+	if node != nil {
+		return node.Height
+	}
+	return -1
+}
+
+/* 更新结点高度 */
+func updateHeight(node *TreeNode) {
+	lh := height(node.Left)
+	rh := height(node.Right)
+	// 结点高度等于最高子树高度 + 1
+	if lh > rh {
+		node.Height = lh + 1
+	} else {
+		node.Height = rh + 1
+	}
+}
+
+/* 获取平衡因子 */
+func balanceFactor(node *TreeNode) int {
+	// 空结点平衡因子为 0
+	if node == nil {
+		return 0
+	}
+	// 结点平衡因子 = 左子树高度 - 右子树高度
+	return height(node.Left) - height(node.Right)
+}
+
+/* 右旋操作 */
+func rightRotate(node *TreeNode) *TreeNode {
+	child := node.Left
+	grandChild := child.Right
+	// 以 child 为原点，将 node 向右旋转
+	child.Right = node
+	node.Left = grandChild
+	// 更新结点高度
+	updateHeight(node)
+	updateHeight(child)
+	// 返回旋转后子树的根节点
+	return child
+}
+
+/* 左旋操作 */
+func leftRotate(node *TreeNode) *TreeNode {
+	child := node.Right
+	grandChild := child.Left
+	// 以 child 为原点，将 node 向左旋转
+	child.Left = node
+	node.Right = grandChild
+	// 更新结点高度
+	updateHeight(node)
+	updateHeight(child)
+	// 返回旋转后子树的根节点
+	return child
+}
+
+/* 执行旋转操作，使该子树重新恢复平衡 */
+func rotate(node *TreeNode) *TreeNode {
+	// 获取结点 node 的平衡因子
+	// Go 推荐短变量，这里 bf 指代 balanceFactor
+	bf := balanceFactor(node)
+	// 左偏树
+	if bf > 1 {
+		if balanceFactor(node.Left) >= 0 {
+			// 右旋
+			return rightRotate(node)
+		} else {
+			// 先左旋后右旋
+			node.Left = leftRotate(node.Left)
+			return rightRotate(node)
+		}
+	}
+	// 右偏树
+	if bf < -1 {
+		if balanceFactor(node.Right) <= 0 {
+			// 左旋
+			return leftRotate(node)
+		} else {
+			// 先右旋后左旋
+			node.Right = rightRotate(node.Right)
+			return leftRotate(node)
+		}
+	}
+	// 平衡树，无需旋转，直接返回
+	return node
+}
+
+/* 插入结点 */
+func (t *avlTree) insert(val int) *TreeNode {
+	t.root = insertHelper(t.root, val)
+	return t.root
+}
+
+/* 递归插入结点（辅助函数） */
+func insertHelper(node *TreeNode, val int) *TreeNode {
+	if node == nil {
+		return NewTreeNode(val)
+	}
+	/* 1. 查找插入位置，并插入结点 */
+	if val < node.Val {
+		node.Left = insertHelper(node.Left, val)
+	} else if val > node.Val {
+		node.Right = insertHelper(node.Right, val)
+	} else {
+		// 重复结点不插入，直接返回
+		return node
+	}
+	// 更新结点高度
+	updateHeight(node)
+	/* 2. 执行旋转操作，使该子树重新恢复平衡 */
+	node = rotate(node)
+	// 返回子树的根节点
+	return node
+}
+
+/* 删除结点 */
+func (t *avlTree) remove(val int) *TreeNode {
+	root := removeHelper(t.root, val)
+	return root
+}
+
+/* 递归删除结点（辅助函数） */
+func removeHelper(node *TreeNode, val int) *TreeNode {
+	if node == nil {
+		return nil
+	}
+	/* 1. 查找结点，并删除之 */
+	if val < node.Val {
+		node.Left = removeHelper(node.Left, val)
+	} else if val > node.Val {
+		node.Right = removeHelper(node.Right, val)
+	} else {
+		if node.Left == nil || node.Right == nil {
+			child := node.Left
+			if node.Right != nil {
+				child = node.Right
+			}
+			// 子结点数量 = 0 ，直接删除 node 并返回
+			if child == nil {
+				return nil
+			} else {
+				// 子结点数量 = 1 ，直接删除 node
+				node = child
+			}
+		} else {
+			// 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+			temp := getInOrderNext(node.Right)
+			node.Right = removeHelper(node.Right, temp.Val)
+			node.Val = temp.Val
+		}
+	}
+	// 更新结点高度
+	updateHeight(node)
+	/* 2. 执行旋转操作，使该子树重新恢复平衡 */
+	node = rotate(node)
+	// 返回子树的根节点
+	return node
+}
+
+/* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+func 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 {
+		// 目标结点在 root 的右子树中
+		if cur.Val < val {
+			cur = cur.Right
+		} else if cur.Val > val {
+			// 目标结点在 root 的左子树中
+			cur = cur.Left
+		} else {
+			// 找到目标结点，跳出循环
+			break
+		}
+	}
+	// 返回目标结点
+	return cur
+}

codes/go/chapter_tree/avl_tree_test.go

@@ -0,0 +1,54 @@
+// File: avl_tree_test.go
+// Created Time: 2023-01-08
+// Author: Reanon (793584285@qq.com)
+
+package chapter_tree
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestAVLTree(t *testing.T) {
+	/* 初始化空 AVL 树 */
+	tree := newAVLTree()
+	/* 插入结点 */
+	// 请关注插入结点后，AVL 树是如何保持平衡的
+	testInsert(tree, 1)
+	testInsert(tree, 2)
+	testInsert(tree, 3)
+	testInsert(tree, 4)
+	testInsert(tree, 5)
+	testInsert(tree, 8)
+	testInsert(tree, 7)
+	testInsert(tree, 9)
+	testInsert(tree, 10)
+	testInsert(tree, 6)
+
+	/* 插入重复结点 */
+	testInsert(tree, 7)
+
+	/* 删除结点 */
+	// 请关注删除结点后，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)
+}
+
+func testInsert(tree *avlTree, val int) {
+	tree.insert(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)
+	PrintTree(tree.root)
+}

codes/go/chapter_tree/binary_search_tree.go

@@ -10,26 +10,26 @@ import (
 	. "github.com/krahets/hello-algo/pkg"
 )
 
-type BinarySearchTree struct {
+type binarySearchTree struct {
 	root *TreeNode
 }
 
-func NewBinarySearchTree(nums []int) *BinarySearchTree {
+func newBinarySearchTree(nums []int) *binarySearchTree {
 	// sorting array
 	sort.Ints(nums)
 	root := buildBinarySearchTree(nums, 0, len(nums)-1)
-	return &BinarySearchTree{
+	return &binarySearchTree{
 		root: root,
 	}
 }
 
-// GetRoot Get the root node of binary search tree
-func (bst *BinarySearchTree) GetRoot() *TreeNode {
+/* 获取根结点 */
+func (bst *binarySearchTree) getRoot() *TreeNode {
 	return bst.root
 }
 
-// GetMin Get node with the min value
-func (bst *BinarySearchTree) GetMin(node *TreeNode) *TreeNode {
+/* 获取中序遍历的下一个结点 */
+func (bst *binarySearchTree) getInOrderNext(node *TreeNode) *TreeNode {
 	if node == nil {
 		return node
 	}
@@ -40,21 +40,8 @@ func (bst *BinarySearchTree) GetMin(node *TreeNode) *TreeNode {
 	return node
 }
 
-// GetInorderNext Get node inorder next
-func (bst *BinarySearchTree) GetInorderNext(node *TreeNode) *TreeNode {
-	if node == nil || node.Right == nil {
-		return node
-	}
-	node = node.Right
-	// 循环访问左子结点，直到叶结点时为最小结点，跳出
-	for node.Left != nil {
-		node = node.Left
-	}
-	return node
-}
-
 /* 查找结点 */
-func (bst *BinarySearchTree) Search(num int) *TreeNode {
+func (bst *binarySearchTree) search(num int) *TreeNode {
 	node := bst.root
 	// 循环查找，越过叶结点后跳出
 	for node != nil {
@@ -74,7 +61,7 @@ func (bst *BinarySearchTree) Search(num int) *TreeNode {
 }
 
 /* 插入结点 */
-func (bst *BinarySearchTree) Insert(num int) *TreeNode {
+func (bst *binarySearchTree) insert(num int) *TreeNode {
 	cur := bst.root
 	// 若树为空，直接提前返回
 	if cur == nil {
@@ -105,7 +92,7 @@ func (bst *BinarySearchTree) Insert(num int) *TreeNode {
 }
 
 /* 删除结点 */
-func (bst *BinarySearchTree) Remove(num int) *TreeNode {
+func (bst *binarySearchTree) remove(num int) *TreeNode {
 	cur := bst.root
 	// 若树为空，直接提前返回
 	if cur == nil {
@@ -149,10 +136,10 @@ func (bst *BinarySearchTree) Remove(num int) *TreeNode {
 		// 子结点数为 2
 	} else {
 		// 获取中序遍历中待删除结点 cur 的下一个结点
-		next := bst.GetInorderNext(cur)
+		next := bst.getInOrderNext(cur)
 		temp := next.Val
 		// 递归删除结点 next
-		bst.Remove(next.Val)
+		bst.remove(next.Val)
 		// 将 next 的值复制给 cur
 		cur.Val = temp
 	}
@@ -173,7 +160,7 @@ func buildBinarySearchTree(nums []int, left, right int) *TreeNode {
 	return root
 }
 
-// Print binary search tree
-func (bst *BinarySearchTree) Print() {
+// print binary search tree
+func (bst *binarySearchTree) print() {
 	PrintTree(bst.root)
 }

codes/go/chapter_tree/binary_search_tree_test.go

@@ -11,34 +11,31 @@ import (
 
 func TestBinarySearchTree(t *testing.T) {
 	nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
-	bst := NewBinarySearchTree(nums)
-	fmt.Println("初始化的二叉树为:")
-	bst.Print()
+	bst := newBinarySearchTree(nums)
+	fmt.Println("\n初始化的二叉树为:")
+	bst.print()
 
 	// 获取根结点
-	node := bst.GetRoot()
-	fmt.Println("二叉树的根结点为:", node.Val)
-	// 获取最小的结点
-	node = bst.GetMin(bst.GetRoot())
-	fmt.Println("二叉树的最小结点为:", node.Val)
+	node := bst.getRoot()
+	fmt.Println("\n二叉树的根结点为:", node.Val)
 
 	// 查找结点
 	node = bst.Search(7)
 	fmt.Println("查找到的结点对象为", node, "，结点值 =", node.Val)
 
 	// 插入结点
-	node = bst.Insert(16)
-	fmt.Println("插入结点后 16 的二叉树为:")
-	bst.Print()
+	node = bst.insert(16)
+	fmt.Println("\n插入结点后 16 的二叉树为:")
+	bst.print()
 
 	// 删除结点
-	bst.Remove(1)
-	fmt.Println("删除结点 1 后的二叉树为:")
-	bst.Print()
-	bst.Remove(2)
-	fmt.Println("删除结点 2 后的二叉树为:")
-	bst.Print()
-	bst.Remove(4)
-	fmt.Println("删除结点 4 后的二叉树为:")
-	bst.Print()
+	bst.remove(1)
+	fmt.Println("\n删除结点 1 后的二叉树为:")
+	bst.print()
+	bst.remove(2)
+	fmt.Println("\n删除结点 2 后的二叉树为:")
+	bst.print()
+	bst.remove(4)
+	fmt.Println("\n删除结点 4 后的二叉树为:")
+	bst.print()
 }

codes/go/chapter_tree/binary_tree_bfs_test.go

@@ -14,11 +14,11 @@ import (
 func TestLevelOrder(t *testing.T) {
 	/* 初始化二叉树 */
 	// 这里借助了一个从数组直接生成二叉树的函数
-	root := ArrayToTree([]int{1, 2, 3, 4, 5, 6, 7})
-	fmt.Println("初始化二叉树: ")
+	root := ArrToTree([]any{1, 2, 3, 4, 5, 6, 7})
+	fmt.Println("\n初始化二叉树: ")
 	PrintTree(root)
 
 	// 层序遍历
 	nums := levelOrder(root)
-	fmt.Println("层序遍历的结点打印序列 =", nums)
+	fmt.Println("\n层序遍历的结点打印序列 =", nums)
 }

codes/go/chapter_tree/binary_tree_dfs_test.go

@@ -14,22 +14,22 @@ import (
 func TestPreInPostOrderTraversal(t *testing.T) {
 	/* 初始化二叉树 */
 	// 这里借助了一个从数组直接生成二叉树的函数
-	root := ArrayToTree([]int{1, 2, 3, 4, 5, 6, 7})
-	fmt.Println("初始化二叉树: ")
+	root := ArrToTree([]any{1, 2, 3, 4, 5, 6, 7})
+	fmt.Println("\n初始化二叉树: ")
 	PrintTree(root)
 
 	// 前序遍历
 	nums = nil
 	preOrder(root)
-	fmt.Println("前序遍历的结点打印序列 =", nums)
+	fmt.Println("\n前序遍历的结点打印序列 =", nums)
 
 	// 中序遍历
 	nums = nil
 	inOrder(root)
-	fmt.Println("中序遍历的结点打印序列 =", nums)
+	fmt.Println("\n中序遍历的结点打印序列 =", nums)
 
 	// 后序遍历
 	nums = nil
 	postOrder(root)
-	fmt.Println("后序遍历的结点打印序列 =", nums)
+	fmt.Println("\n后序遍历的结点打印序列 =", nums)
 }