golang二叉树

package main

import (
	"container/list"
	"fmt"
)

// Binary Tree
type BinaryTree struct {
	Data  interface{}
	Left  *BinaryTree
	Right *BinaryTree
}

// Constructor
func NewBinaryTree(data interface{}) *BinaryTree {
	return &BinaryTree{Data: data}
}

// 先序遍历-非递归
func (bt *BinaryTree) PreOrderNoRecursion() []interface{} {
	t := bt
	stack := list.New()
	res := make([]interface{}, 0)
	for t != nil || stack.Len() != 0 {
		for t != nil {
			res = append(res, t.Data)//visit
			stack.PushBack(t)
			t = t.Left
		}
		if stack.Len() != 0 {
			v := stack.Back()
			t = v.Value.(*BinaryTree)
			t = t.Right
			stack.Remove(v)
		}
	}
	return res
}

// 中序遍历-非递归
func (bt *BinaryTree) InOrderNoRecursion() []interface{} {
	t := bt
	stack := list.New()
	res := make([]interface{}, 0)
	for t != nil || stack.Len() != 0 {
		for t != nil {
			stack.PushBack(t)
			t = t.Left
		}
		if stack.Len() != 0 {
			v := stack.Back()
			t = v.Value.(*BinaryTree)
			res = append(res, t.Data)//visit
			t = t.Right
			stack.Remove(v)
		}
	}
	return res
}

// 后序遍历-非递归
func (bt *BinaryTree) PostOrderNoRecursion() []interface{} {
	t := bt
	stack := list.New()
	res := make([]interface{}, 0)
	var preVisited *BinaryTree

	for t != nil || stack.Len() != 0 {
		for t != nil {
			stack.PushBack(t)
			t = t.Left
		}

		v   := stack.Back()
		top := v.Value.(*BinaryTree)

		if (top.Left == nil && top.Right == nil) || (top.Right == nil && preVisited == top.Left) || preVisited == top.Right{
			res = append(res, top.Data)//visit
			preVisited = top
			stack.Remove(v)
		}else {
			t = top.Right
		}
	}
	return res
}



func main() {
	t := NewBinaryTree(1)
	t.Left  = NewBinaryTree(3)
	t.Right = NewBinaryTree(6)
	t.Left.Left = NewBinaryTree(4)
	t.Left.Right = NewBinaryTree(5)
	t.Left.Left.Left = NewBinaryTree(7)

	fmt.Println(t.PreOrderNoRecursion())
	fmt.Println(t.InOrderNoRecursion())
	fmt.Println(t.PostOrderNoRecursion())
}

版本二

package main

import "fmt"

func main() {

   arr := []int{10, 5, 24, 30, 60, 40, 45, 15, 27, 49, 23, 42, 56, 12, 8, 55, 2, 9}
   fmt.Println(arr)
   t := creatTree(arr)
   preorder(t[0])
   fmt.Println()
   inorder(t[0])
   fmt.Println()
   afterorder(t[0])

}

type tree struct {
   data  int
   left  *tree
   right *tree
}

//创建二叉树
func creatTree(arr []int) []tree {
   d := make([]tree, 0)
   for i, ar := range arr {
      d = append(d, tree{})
      d[i].data = ar
   }
   for i := 0; i < len(arr)/2; i++ {
      d[i].left = &d[i*2+1]
      if i*2+2 < len(d) {
         d[i].right = &d[i*2+2]
      }
   }
   fmt.Println(d)
   return d
}

//前序遍历
func preorder(root tree) {
   fmt.Print(root.data, " ")
   if root.left != nil {
      preorder(*root.left)
   }
   if root.right != nil {
      preorder(*root.right)
   }
}

//中序遍历
func inorder(root tree) {
   if root.left != nil {
      inorder(*root.left)
   }
   fmt.Print(root.data, " ")
   if root.right != nil {
      inorder(*root.right)
   }
}

//后序遍历
func afterorder(root tree) {
   if root.left != nil {
      afterorder(*root.left)
   }
   if root.right != nil {
      afterorder(*root.right)
   }
   fmt.Print(root.data, " ")
}

版本三

package main

import "fmt"

type BiliTree struct {
	LTree *BiliTree
	RTree *BiliTree
	Data  int
}

func Trans(root*BiliTree)  {
	if root==nil {
		return
	}
	Trans(root.LTree)
	Trans(root.RTree)
	fmt.Println(root.Data)

}

func main() {
	root := new(BiliTree)
	root.Data=3

	lt := new(BiliTree)
	lt.Data=4
	root.LTree=lt

	rt := new(BiliTree)
	rt.Data=5
	root.RTree=rt

	Trans(root)

}