Javascript 逐层遍历树

下面是json树

interface Tree {
    v: number, // value
    c: Tree[], // children
}

const tree: Tree = {
    v: 0, c: [
        {
            v: 1,
            c: [
                {
                    v: 4,
                    c: [
                        {
                            v: 9, c: [],
                        }
                    ],
                },
                {
                    v: 5,
                    c: [
                        {
                            v: 10, c: [],
                        }
                    ],
                },
            ],
        },
        {
            v: 2,
            c: [
                {
                    v: 6,
                    c: [
                        {
                            v: 11, c: [],
                        }
                    ],
                },
                {
                    v: 7,
                    c: [
                        {
                            v: 12, c: [],
                        }
                    ],
                }
            ],
        },
        {
            v: 3,
            c: [
                {
                    v: 8,
                    c: [
                        {
                            v: 13, c: [],
                        },
                        {
                            v: 14, c: [],
                        },
                    ]
                }
            ],
        },
    ]
}

如何逐层遍历树

换句话说，如果每个节点上应用的函数只是

console.log

上述输入应打印0、1、2、3、4、5、6、7、8、9、10、12、13、14

或者更好，我们可以按级别打印，输出结果如下：

Level 0: [0]
Level 1: [1,2,3]
LeveL 2: [4,5,6,7,8]
Level 3: [9,10,11,12,13,14]

失败的尝试

function walkTree(t){
        console.log(t.v);
        for(const child of t.c){
            walkTree(child)
        }
}

---

您需要将来自每个级别的所有值存储在一个数组中，并将该数组与所经过的每个级别一起传递。然后在末尾返回该数组，使其返回。这就是你将如何得到你正在寻找的结构

然后循环遍历结果并用值记录文本

见下面的例子

const树={
v:0，
c:[
{
五:一,，
c:[
{
五:四,，
c:[
{
v:9，c:[]，
}
],
},
{
五:五,，
c:[
{
v:10，c:[]，
}
],
},
],
},
{
五:二,，
c:[
{
五:六,，
c:[
{
v:11，c:[]，
}
],
},
{
五:七,，
c:[
{
v:12，c:[]，
}
],
}
],
},
{
五:三,，
c:[
{
五:八,，
c:[
{
v:13，c:[]，
},
{
v:14，c:[]，
},
]
}
],
},
]
}
函数walkTree（树，级别=0，集合=[]））{
//从该级别中选择值。
常数{c，v}=树；
//如果此级别没有数组，请为此级别创建一个数组。
如果（！Array.isArray（集合[级别]）{
集合[级别]=[]；
}
//将此级别的值存储在数组中。
收集[级别]。推送（v）；
//在子级别上循环，并在增加级别的同时向下传递集合。
for（c的常量子树）{
集合=walkTree（子树，级别+1，集合）；
}
//返回每个级别的集合。
回收；
}
//开始走路。
const result=walkTree（树）；
result.forEach（（值，索引）=>{
log（`Level${index}:`，value）；
});这里是一个使用

一个优点是，您可以在
filterFn
中访问元信息，因此可以轻松地进行其他处理。然而，引入依赖关系显然是一种权衡


//const objectScan=require（'object-scan'）；
常量myTree={v:0，c:[{v:1，c:[{v:4，c:[{v:9，c:[]}，{v:5，c:[{v:10，c:[]}}，{v:2，c:[{v:6，c:[{v:11，c:[]}}，{v:7，c:[{v:12，c:[]}}}，{v:3，c:[{v:8，c:[]v:13，c:[]}，c:[]14}；
constbylevel=（树）=>objectScan（['**']{
filterFn:（{isLeaf，key，value，context}）=>{
如果（isLeaf）{
常量级别=（key.length-1）/2；
如果（！（上下文中的级别））{
上下文[级别]=[]；
}
上下文[级别]。推送（值）；
}
}
})（树，[]）；
log（byLevel（myTree））；
/* =>
[ [ 0 ],
[ 3, 2, 1 ],
[ 8, 7, 6, 5, 4 ],
[ 14, 13, 12, 11, 10, 9 ] ]
*/
。作为控制台包装{最大高度：100%！重要；顶部：0}
由于这已被恢复

对树进行相当简单的广度优先扫描可能如下所示：


constbreadthfirst=（tree，xs=[].concat（tree））=>
xs.length==0
? [] 
：[xs.map（x=>x.v），…breadthFirst（xs.flatMap（x=>x.c））]
常量树={v:0，c:[{v:1，c:[{v:4，c:[{v:9，c:[]}}，{v:5，c:[{v:10，c:[]}}，{v:2，c:[{v:6，c:[{v:11，c:[]}}，{v:7，c:[{v:12，c:[]}}}，{v:3，c:[{v:8，c:[]13，c:[]
log（breadthFirst（tree））
您尝试过任何特定的方法吗？我尝试过递归函数。但它是按分支遍历的，并没有向我们展示递归函数。这应该是正确的方法，但可能是您的实现失败了。
函数walkTree（t）{console.log（t.v）；for（t.c的const child）{walkTree（child）}