leetcode 根据数组创建二叉树

问题遇到的现象和发生背景

在Leetcode 刷题时需要按照题目要求利用题目给出的数组构建二叉树,以方便在本地调试,网上有一些版本,比如:

https://blog.csdn.net/baoxin1100/article/details/108025393

但是这些都没有golang语言的版本,请问有无golang的版本. 本人除了go,其它语言都不懂.

万分感谢.

用代码块功能插入代码，请勿粘贴截图

参考下下面链接
https://blog.csdn.net/cdzg_zzk/article/details/120254462

你好，这里有一篇go语言的，康康是否有帮助
https://zhuanlan.zhihu.com/p/552327473


package main
 
import "fmt"
 
type btNode struct {
    Data   interface{}
    Lchild *btNode
    Rchild *btNode
}
 
type biTree struct {
    root *btNode
}
 
func (bt *biTree) preOrder() []interface{} {
    var res []interface{}
    p := bt.root
    Stack := make([]*btNode, 0)
    for p != nil || len(Stack) > 0 {
        for p != nil {
            res = append(res, p.Data)
            Stack = append(Stack, p)
            p = p.Lchild
        }
        if len(Stack) > 0 {
            p = Stack[len(Stack)-1]
            Stack = Stack[:len(Stack)-1]
            p = p.Rchild
        }
    }
    return res
}
 
func (bt *biTree) inOrder() []interface{} {
    var res []interface{}
    p := bt.root
    Stack := make([]*btNode, 0)
    for p != nil || len(Stack) > 0 {
        for p != nil {
            Stack = append(Stack, p)
            p = p.Lchild
        }
        if len(Stack) > 0 {
            p = Stack[len(Stack)-1]
            res = append(res, p.Data)
            Stack = Stack[:len(Stack)-1]
            p = p.Rchild
        }
    }
    return res
}
 
func (bt *biTree) postOrder() []interface{} {
    var res []interface{}
    var cur, pre *btNode
    Stack := make([]*btNode, 0)
    Stack = append(Stack, bt.root)
    for len(Stack) > 0 {
        cur = Stack[len(Stack)-1]
        if cur.Lchild == nil && cur.Rchild == nil ||
            pre != nil && (pre == cur.Lchild || pre == cur.Rchild) {
            res = append(res, cur.Data)
            Stack = Stack[:len(Stack)-1]
            pre = cur
        } else {
            if cur.Rchild != nil {
                Stack = append(Stack, cur.Rchild)
            }
            if cur.Lchild != nil {
                Stack = append(Stack, cur.Lchild)
            }
        }
    }
    return res
}
 
func createTree(list []interface{}) *biTree {
    btree := &biTree{}
    if len(list) > 0 {
        btree.root = &btNode{Data: list[0]}
        for _, data := range list[1:] {
            btree.appendNode(data)
        }
    }
    return btree
}
 
func (bt *biTree) appendNode(data interface{}) {
    cur := bt.root
    if cur == nil {
        bt = &biTree{}
        return
    }
    Queue := []*btNode{cur}
    for len(Queue) > 0 {
        cur := Queue[0]
        Queue = Queue[1:]
        if cur.Lchild != nil {
            Queue = append(Queue, cur.Lchild)
        } else {
            cur.Lchild = &btNode{Data: data}
            return
        }
        if cur.Rchild != nil {
            Queue = append(Queue, cur.Rchild)
        } else {
            cur.Rchild = &btNode{Data: data}
            break
        }
    }
}
 
func main() {
 
    list := []interface{}{1, 2, 3, 4, 5, 6, 7, 8}
    tree := createTree(list)
 
    fmt.Println(tree.preOrder())
    fmt.Println(tree.inOrder())
    fmt.Println(tree.postOrder())
 
}
 
/*
[1 2 4 8 5 3 6 7]
[8 4 2 5 1 6 3 7]
[8 4 5 2 6 7 3 1]
*/