go语言实现二叉树的前序遍历、中序遍历、后续遍历、广度优先遍历和深度优先遍历

一、什么是二叉树？
每个节点最多只能有两个子节点的树叫二叉树，如果除了树的最后一层之外其他层都有左右子节点，这样的树称为完全二叉树

这就是一颗完全二叉树
（1）前序遍历：根结点 —> 左子树 —> 右子树
（2）中序遍历：左子树—> 根结点 —> 右子树
（3）后序遍历：左子树 —> 右子树 —> 根结点
（4）广度优先遍历：从根节点一层层从左向右遍历
（5）深度优先：和前序遍历一样
二、go语言代码实现

type BiTree interface {

	Inorder(tree *Node)     /*中序遍历*/

	Preorder(tree *Node)    /*先序遍历*/

	Postorder(tree *Node) 	/*后续遍历*/

	Bforder(tree *Node) 	/*广度优先遍历*/

	Dforder(tree *Node)		/*深度优先遍历*/
}

/*二叉树树的每一个节点数据结构*/
type Node struct {
	Data interface{} 	/*树的数据*/

	Left *Node  		/*树的左节点*/

	Right *Node			/*树的右节点*/
}

func (n Node) Inorder(tree *Node) {
	if tree == nil {
		return
	}
	n.Inorder(tree.Left)
	fmt.Print(tree.Data," ")
	n.Inorder(tree.Right)
}

func (n Node) Preorder(tree *Node) {
	if tree == nil {
		return
	}
	fmt.Print(tree.Data," ")
	n.Preorder(tree.Left)
	n.Preorder(tree.Right)
}

func (n Node) Postorder(tree *Node) {
	if tree == nil {
		return
	}
	n.Postorder(tree.Left)
	n.Postorder(tree.Right)
	fmt.Print(tree.Data," ")
}

func (n Node) Bforder(tree *Node) {
	if tree == nil {
		fmt.Println("Bforder : tree is empty")
		return
	}
	element := make([]interface{},0)
	queue := queue.NewLinkedList()
	/*根节点先入队列*/
	queue.Offer(tree)
	for !queue.IsEmpty() {
		/*出队列*/
		node  := queue.Poll().(*Node)
		if node.Left != nil{
			queue.Offer(node.Left)
		}
		if node.Right != nil {
			queue.Offer(node.Right)
		}
		element = append(element,node.Data)
	}
	for i :=0 ;i < len(element); i++ {
		fmt.Print(element[i]," ")
	}
	fmt.Println()
}

func (n Node) Dforder(tree *Node) {
	if tree == nil {
		fmt.Println("Dforder : tree is empty")
		return
	}
	element := make([]interface{},0)
	stack := stack2.NewStack()
	stack.Push(&n)
	for !stack.IsEmpty() {
		node := stack.Pop().(*Node)
		element = append(element,node.Data)
		if node.Right != nil {
			stack.Push(node.Right)
		}
		if  node.Left != nil  {
			stack.Push(node.Left)
		}
	}
	for i :=0 ;i < len(element); i++ {
		fmt.Print(element[i]," ")
	}
	fmt.Println()
}
func main()  {
	tree := &tree2.Node{
		Data:  "A",
		Left:  &tree2.Node{
			Data:  "B",
			Left:  &tree2.Node{
				Data:  "D",
				Left:  nil,
				Right: nil,
			},
			Right: &tree2.Node{
				Data:  "C",
				Left:  nil,
				Right: &tree2.Node{
					Data:  "H",
					Left:  nil,
					Right: nil,
				},
			},
		},
		Right: &tree2.Node{
			Data:  "E",
			Left:  &tree2.Node{
				Data:  "G",
				Left:  nil,
				Right: nil,
			},
			Right: &tree2.Node{
				Data:  "F",
				Left:  nil,
				Right: nil,
			},
		},
	}
	/*前序遍历*/
	tree.Preorder(tree)
	fmt.Println()
	/*中序遍历*/
	tree.Inorder(tree)
	fmt.Println()
	/*后续遍历*/
	tree.Postorder(tree)
	fmt.Println()
	/*广度优先*/
	tree.Bforder(tree)
	/*深度优先*/
	tree.Dforder(tree)
}