golang二叉树创建、递归非递归前、中、后遍历

package main 
import(
    "fmt"
)

type BitTree struct{
    value int
    left *BitTree
    right *BitTree
}

func create() *BitTree{
    //root
    p := new(BitTree)
    p.value = 4
    //second floor
    p1 := new(BitTree)
    p2 := new(BitTree)
    p.left = p1
    p.right = p2
    p1.value = 3
    p2.value = 8
    //third floor
    p11 := new(BitTree)
    p12 := new(BitTree)
    p1.left = p11
    p1.right = p12
    p11.value = 5
    p12.value = 6
    p11.left = nil
    p12.right = nil
    p21 := new(BitTree)
    p2.left = p21
    p2.right = nil
    p21.value = 7
    p21.left = nil
    p21.right = nil
    return p
}

var i = -1
func createByArr(a []int)*BitTree{
    i += 1
    //fmt.Println("len(a)", len(a))
    if i >= len(a){
        return nil
    }
    t := new(BitTree)
    if a[i] != 0{
        t.value = a[i]
        t.left = nil
        t.right = nil
        t.left = createByArr(a)
        t.right = createByArr(a)
    }else{
        return nil
    }
    return t
}

func Pre(bt *BitTree){
    if bt != nil{
        fmt.Printf("%d  ", bt.value)
        Pre(bt.left)
        Pre(bt.right)
    }
}

func Midd(bt *BitTree){
    if bt != nil{
        Midd(bt.left)
        fmt.Printf("%d  ", bt.value)
        Midd(bt.right)
    }
}

func Aft(bt *BitTree){
    if bt != nil{
        Aft(bt.left)
        Aft(bt.right)
        fmt.Printf("%d  ", bt.value)
    }
}

//非递归操作
//栈定义
type Stack struct{
    data [100]*BitTree
    tag [100]int
    top int
}

//pre
func Pre1(bt *BitTree){
    if bt == nil{
        return 
    }
    stack := new(Stack)
    stack.top = -1
    for bt != nil || stack.top != -1{
        for bt != nil{
            fmt.Printf("%d  ", bt.value)
            stack.top++
            stack.data[stack.top] = bt
            bt = bt.left
        }
        bt = stack.data[stack.top]
        stack.top--
        bt = bt.right
    }
}

//Midd
func Midd1(bt *BitTree){
    if bt == nil{
        return 
    }
    stack := new(Stack)
    stack.top = -1
    for bt != nil || stack.top != -1{
        for bt != nil{
            stack.top++
            stack.data[stack.top] = bt
            bt = bt.left
        }
        bt = stack.data[stack.top]
        fmt.Printf("%d  ", bt.value)
        stack.top--
        bt = bt.right
    }
}

//Aft
func Aft1(bt *BitTree) {
    if bt == nil{
        return
    }
    stack := new(Stack)
    stack.top = -1
    for bt != nil || stack.top != -1{
        for bt != nil{
            stack.top++
            stack.data[stack.top] = bt
            stack.tag[stack.top] = 0//访问标记，0代表第一次访问,1为第二次访问
            bt = bt.left
        }
        if stack.tag[stack.top] == 0{
            //只访问过一次，转向同层右节点
            bt = stack.data[stack.top]
            stack.tag[stack.top] = 1
            bt = bt.right
        }else{
            //找出栈中非第一次访问的节点
            for stack.tag[stack.top] == 1{
                bt = stack.data[stack.top]
                stack.top--
                fmt.Printf("%d  ", bt.value)
                if stack.top < 0{
                    break
                }
                
            }
            bt = nil
        }
    }
}

func main(){
    //cretae
    bt := create()
    //pre
    fmt.Println("Pre:")
    Pre(bt)
    fmt.Println()
    fmt.Println("Pre11:")
    Pre1(bt)
    fmt.Println()
    //midd
    fmt.Println("Midd:")
    Midd(bt)
    fmt.Println()
    fmt.Println("Midd1:")
    Midd1(bt)
    fmt.Println()
    //after
    fmt.Println("Aft:")
    Aft(bt)
    fmt.Println()
    fmt.Println("Aft1:")
    Aft1(bt)
    fmt.Println()

    var arr = []int{5, 8, 10, 0, 0, 11, 0, 0,9,13,0,0,14,0,0}
    bt1 := createByArr(arr)
    fmt.Println("Pre1:")
    Pre(bt1)
    fmt.Println()
    fmt.Println("Pre12:")
    Pre1(bt1)
    fmt.Println()
    //midd
    fmt.Println("Midd1:")
    Midd(bt1)
    fmt.Println()
    fmt.Println("Midd12:")
    Midd1(bt1)
    fmt.Println()
    //after
    fmt.Println("Aft1:")
    Aft(bt1)
    fmt.Println()

    fmt.Println("Aft12:")
    Aft1(bt1)
    fmt.Println()
}