平衡二叉搜索树实现（go）

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func sortedArrayToBST(nums []int) *TreeNode {
	if len(nums) == 0 {
		return nil
	}
	var root *TreeNode
	for i := 0; i < len(nums); i++ {
		root = insert(root, nums[i])
	}
	return root
}

// 实现平衡BST
func insert(root *TreeNode, key int) *TreeNode {
	if root == nil {
		root = &TreeNode{Val:key}
	} else if root.Val > key {
		root.Left = insert(root.Left, key)
		if getHeight(root.Left) - getHeight(root.Right) > 1 {
			if root.Left.Val > key { // 左左
				root = adjustLL(root)
			} else { // 左右
				root = adjustLR(root)
			}
		}
	} else if root.Val < key {
		root.Right = insert(root.Right, key)
		if getHeight(root.Right) - getHeight(root.Left) > 1 {
			if root.Right.Val < key { // 右右
				root = adjustRR(root)
			} else {
				root = adjustRL(root)
			}
		}
	} else {
		return nil
	}
	return root
}

func getHeight(t *TreeNode) int {
	if t == nil {
		return 0
	}
	return max(getHeight(t.Left), getHeight(t.Right)) + 1
}

func max(a, b int) int {
	if a < b {
		return b
	}
	return a
}
// 左左插入节点导致BST不平衡
func adjustLL(t *TreeNode) *TreeNode {
	tempNode := t.Left
	t.Left = tempNode.Right
	tempNode.Right = t
	t = tempNode
	return tempNode
}

// 右右插入节点导致BST不平衡
func adjustRR(t *TreeNode) *TreeNode {
	tempNode := t.Right
	t.Right = tempNode.Left
	tempNode.Left = t
	t = tempNode
	return tempNode
}

// 左右插入节点导致BST不平衡
func adjustLR(t *TreeNode) *TreeNode {
	t.Left = adjustRR(t.Left)
	return adjustLL(t)
}

// 右左插入节点导致BST不平衡
func adjustRL(t *TreeNode) *TreeNode {
	t.Right = adjustLL(t.Right)
	return adjustRR(t)
}