go语言实现二叉查找树相关操作

一、什么是二叉查找树？
二叉查找树满足以下特点
（1）树的左子树的值全部小于父节点的值
（2）树的右子树的值全部大于父节点的值
（3）左、右子树也分别满足条件（1）（2）
（4）树上所有节点的值不能相等

二、程序实现

package tree


func InsertNode(root *Node,value int)  *Node{
	/*右子树或者左子树为nil，就添加节点 ，递归退出条件*/
	if root == nil {
		root = &Node{
			Data:  value,
			Left:  nil,
			Right: nil,
		}
		return root
	}

	/*元素已经存在，直接返回，递归退出条件*/
	if root.Data.(int) == value {
		return root
	}
	if value < root.Data.(int) {
		/*小于父节点的值，往左子树添加元素*/
		root.Left = InsertNode(root.Left,value)
	}else {
		/*大于父节点的值，往左子树添加元素*/
		root.Right = InsertNode(root.Right,value)
	}

	return root

}

func CreateBSTree(root *Node, value[] int, n int)  {
	for i := 0 ; i< n ; i++ {
		InsertNode(root,value[i])
	}
}

func SearchNode(root *Node,value int) bool  {
	/*没查到返回false，递归退出条件*/
	if root  == nil{
		 return false
	}
	/*查到返回true，递归退出条件*/
	if root.Data.(int) == value {
		return true
	}
	if value < root.Data.(int) {
		/*递归查询右子树*/
		return SearchNode(root.Left,value)
	}else {
		/*递归查询左子树*/
		return SearchNode(root.Right,value)
	}
}



func FindMaxNode(root *Node) *Node {
	if root == nil {
		return nil
	}

	if root.Right == nil {
		return root
	}else {
		return FindMaxNode(root.Right)
	}
}


func FindMinNode(root *Node) *Node {
	if root == nil {
		return nil
	}

	if root.Left == nil {
		return root
	}else {
		return FindMinNode(root.Left)
	}
}

/*第一个是父结点，第二个是子节点*/
func DeleteMinValue(root *Node,left *Node) interface{} {
	if left == nil {
		/*根结点的左子树为空的情况*/
		left = root.Right
	}

	/*只有根结点的情况*/
	if left == nil{
		return nil
	}

	if left.Left == nil{
		v := left.Data
		if root.Left == left {
			/*第二层结点的删除比较特殊*/
			root.Left = left.Right
		}else {
			/*左孩子结点必然是最小，直接删除*/
			root.Left = nil
			/*父结点的右节点指向子节点的右侧结点*/
			root.Right = left.Right
		}
		return  v
	}
	return DeleteMinValue(left,left.Left)
}

/*第一个是父结点，第二个是子节点*/
func DeleteMaxValue(root *Node, right *Node) interface{} {

	if right == nil {
		/*右子树已经删除光的情况下*/
		right = root.Left
	}

	/*整个树都删除，只剩下跟结点的情况*/
	if right == nil {
		return nil
	}
	if right.Right == nil{
		v := right.Data
		if root.Right == right {
			/*第二层结点的删除比较特殊*/
			root.Right = right.Left
		}else {
			/*右孩子结点必然是最小大，直接删除*/
			root.Right = nil
			/*父结点的右节点指向子节点的右侧结点*/
			root.Left = right.Left
		}
		return  v
	}
	return DeleteMaxValue(right, right.Right)
}

func DeleteNode(root *Node, value interface{}) bool{
	/*如果没有找到元素就直接退出*/
	if root == nil {
		return false
	}

	/*如果是左叶结点直接删除*/
	if FindMinNode(root).Data == value  {
		DeleteMinValue(root,root.Left)
		return true
	}

	/*如果是右叶结点直接删除*/
	if  FindMaxNode(root).Data == value  {
		DeleteMaxValue(root,root.Right)
		return true
	}

	/*非叶结点删除，找到后就为了保持查找二叉树的特性，必须删除最小的结点，将最小结点的值，替换调被删除的结点*/
	if root.Data == value {
		root.Data = DeleteMinValue(root,root.Left)
		return true
	}

	if root.Data.(int) > value.(int) {
		/*递归左子树*/
		return DeleteNode(root.Left,value)
	}else {
		/*递归右子树*/
		return DeleteNode(root.Right,value)
	}

}

func main()  {
	values := [...]int{8,2,5,6,10,3,5,9,1,14}
	var root = &tree.Node{
		Data: 8,
	}
	tree.CreateBSTree(root,values[:], len(values))
	root.Inorder(root)
	fmt.Println()
	deleted := tree.DeleteNode(root,2)
	fmt.Println(deleted)
	root.Inorder(root)
	deleted = tree.DeleteNode(root,9)
	fmt.Println(deleted)
	root.Inorder(root)
}

三**、二叉查找树的效率**

指定n个元素，如果构成的树深度为n，查找效率为O(n)，最好的情况构成一颗完全二叉树，时间复杂度为O(log2n) ,2为底数，相当于排序数组的对半查找