Add build script for Go and update Go codes.

codes/go/chapter_tree/avl_tree.go

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

codes/go/chapter_tree/avl_tree_test.go

@@ -41,13 +41,13 @@ func TestAVLTree(t *testing.T) {
 	fmt.Printf("\n查找到的结点对象为 %#v ，结点值 = %d \n", node, node.Val)
 }
 
-func testInsert(tree *avlTree, val int) {
+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) {
+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

@@ -15,12 +15,26 @@ type binarySearchTree struct {
 }
 
 func newBinarySearchTree(nums []int) *binarySearchTree {
-	// sorting array
+	// 排序数组
 	sort.Ints(nums)
-	root := buildBinarySearchTree(nums, 0, len(nums)-1)
-	return &binarySearchTree{
-		root: root,
+	// 构建二叉搜索树
+	bst := &binarySearchTree{}
+	bst.root = bst.buildTree(nums, 0, len(nums)-1)
+	return bst
+}
+
+/* 构建二叉搜索树 */
+func (bst *binarySearchTree) buildTree(nums []int, left, right int) *TreeNode {
+	if left > right {
+		return nil
 	}
+	// 将数组中间结点作为根结点
+	middle := left + (right-left)>>1
+	root := NewTreeNode(nums[middle])
+	// 递归构建左子树和右子树
+	root.Left = bst.buildTree(nums, left, middle-1)
+	root.Right = bst.buildTree(nums, middle+1, right)
+	return root
 }
 
 /* 获取根结点 */
@@ -146,21 +160,7 @@ func (bst *binarySearchTree) remove(num int) *TreeNode {
 	return cur
 }
 
-// buildBinarySearchTree Build a binary search tree from array.
-func buildBinarySearchTree(nums []int, left, right int) *TreeNode {
-	if left > right {
-		return nil
-	}
-	// 将数组中间结点作为根结点
-	middle := left + (right-left)>>1
-	root := NewTreeNode(nums[middle])
-	// 递归构建左子树和右子树
-	root.Left = buildBinarySearchTree(nums, left, middle-1)
-	root.Right = buildBinarySearchTree(nums, middle+1, right)
-	return root
-}
-
-// print binary search tree
+/* 打印二叉搜索树 */
 func (bst *binarySearchTree) print() {
 	PrintTree(bst.root)
 }

codes/go/chapter_tree/binary_tree_bfs.go

@@ -11,7 +11,7 @@ import (
 )
 
 /* 层序遍历 */
-func levelOrder(root *TreeNode) []int {
+func hierOrder(root *TreeNode) []int {
 	// 初始化队列，加入根结点
 	queue := list.New()
 	queue.PushBack(root)

codes/go/chapter_tree/binary_tree_bfs_test.go

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