Go 广度优先遍历 多叉树

遇到个需求是要求广度优先遍历多叉树，找了一下，c版本的比较多，go版本的没几个，记录一下。

解决的关键是使用队列

package main

import "fmt"

type TreeNode struct {
    NodeId     int
    ChildNodes []TreeNode
}

/*
           1
    2      3       4
 5 6 7    8 9     10

正确的顺序： 1 2 3 4 5 6 7 8 9 10

*/

func main() {
    // 构造一颗树
    var tree = TreeNode{
        NodeId: 1,
        ChildNodes: []TreeNode{
            {
                NodeId: 2,
                ChildNodes: []TreeNode{
                    {NodeId: 5},
                    {NodeId: 6},
                    {NodeId: 7},
                },
            },
            {
                NodeId: 3,
                ChildNodes: []TreeNode{
                    {NodeId: 8},
                    {NodeId: 9},
                },
            },
            {
                NodeId: 4,
                ChildNodes: []TreeNode{
                    {NodeId: 10},
                },
            },
        },
    }

    BfsTree(tree)

}

var nodeIds = make([]int, 0)

func BfsTree(tree TreeNode) {
    // 初始化队列
    queue := []TreeNode{tree}
    // 当队列中没有元素，那么结束
    for len(queue) > 0 {
        var count = 0
        for i := range queue {
            // 计数+1
            count++
            // 保存值
            nodeIds = append(nodeIds, queue[i].NodeId)
            // 子节点入队
            for j := range queue[i].ChildNodes {
                queue = append(queue, queue[i].ChildNodes[j])
            }

        }
        // 类似于出队，将遍历过的删掉
        queue = queue[count:]

    }
    fmt.Printf("%+v\n", nodeIds) // [1 2 3 4 5 6 7 8 9 10]

}