go二叉搜索树

//二叉搜索树

package tree

import "fmt"


type Item  interface{}


type Node struct{
	Key int
	Value Item
	left *Node
	right *Node
}


type BinarySearch interface{
	Insert(key int,value Item)
	Min() *Item
	Max() *Item
	Search(key int) bool
	PreOrder()
}

type ItemBinarySearchTree struct{
	Root *Node
}


func (bst *ItemBinarySearchTree) Insert(key int,value Item){
	n :=&Node{key,value,nil,nil}

	if bst.Root == nil{
		bst.Root =n
	}else{
		insertNode(bst.Root,n)
	}
}

func insertNode(node,n1 *Node){
	if n1.key < node.key{
		if node.left == nil{
			node.left = n1
		}else{
			insertNode(node.left,n1)
		}
	}else{
		insertNode(node.right,n1)
	}
}

func (bst *ItemBinarySearchTree) Min() *Item{
	n :=bst.Root

	if n == nil{
		return nil
	}

	for{
		if n.left == nil{
			return &n.Value
		}else{
			n = n.left
		}

	}
} 

func (bst *ItemBinarySearchTree) Max() *Item{
	n :=bst.Root

	if n == nil{
		return nil
	}

	for{
		if n.right == nil{
			return &n.Value
		}else{
			n = n.right
		}

	}
} 



func (bst *ItemBinarySearchTree) PreOrder(){
	n :=bst.Root
	if n == nil{
		return
	}
	fmt.Println(n.Value)
	n.left.PreOrder()
	n.right.PreOrder()
}

 

二叉树前中后序：

package main


import "fmt"


type Item interface{}

type treeNode struct{
	value Item
	left *treeNode
	right *treeNode
}


/*   
           A1
       B2        C3

    D4   E5    G7   I9

       F6         H8


*/

func main(){
	root :=treeNode{"A1",nil,nil}

	root.left = &treeNode{value:"B2"}
	root.right = &treeNode{value:"C3"}
	root.left.left = &treeNode{value:"D4"}
	root.left.right = &treeNode{value:"E5"}
	root.left.right.left = new(treeNode)
	root.left.right.left.value = "F6"
	 
	root.right.left = &treeNode{value:"G7"}
	root.right.left.right = &treeNode{value:"H8"}
	root.right.right = &treeNode{value:"I9"}

	root.PreOrder() 
	root.Inorder()
	root.Postorder()

}


func (n *treeNode) PreOrder(){
	if n == nil{
		return
	}
	fmt.Println(n.value)
	n.left.PreOrder()
	n.right.PreOrder()
}



func (node *treeNode) Inorder(){
   if(node == nil){
      return
   }
   node.left.Inorder()
   fmt.Println(node.value)
   node.right.Inorder()
}



func (node *treeNode) Postorder(){
   if(node == nil){
      return
   }
   node.left.Postorder()
   node.right.Postorder()
   fmt.Println(node.value)
}


 // Pre:
A1
B2
D4
E5
F6
C3
G7
H8
I9

//  In:
D4
B2
F6
E5
A1
G7
H8
C3
I9


//
D4
F6
E5
B2
H8
G7
I9
C3
A1

参考：https://blog.csdn.net/weixin_42178081/article/details/82155914