Jw
首页
技术
英语
首页
技术
英语
  • 前端

    • JavaScript

      • Methods

        • Scheduler
        • Deep Clone
        • Curry
        • Calculation Function
        • debounce & throttle
      • Function bind
      • Array reduce
      • cross domain
      • event loop
      • ajax
      • event
      • context
      • inheritance
      • prototype
      • __proto__ 与原型链
      • 手写 Promise
      • LazyMan 链式调用
      • 多叉树遍历
      • 返回顶部 ToTop
      • JS 工具函数

多叉树遍历

递归、非递归广度优先、非递归深度优先三种多叉树遍历实现。

    
     //递归实现
    console.time('------------- 递归实现 ------------------');
    var parseTreeJson = async function(treeNodes){
        if (!treeNodes || !treeNodes.length) return;

        for (var i = 0, len = treeNodes.length; i < len; i++) {

            var childs = treeNodes[i].children;
            
            console.log(treeNodes[i].id);

            if(childs && childs.length > 0){
                parseTreeJson(childs);
            }
        }
    };


    
    console.timeEnd('------------- 递归实现 ------------------');


    //非递归广度优先实现
    console.time('------------- 非递归广度优先实现 ------------------');
    
    var iterator1 = async function (treeNodes) {
        if (!treeNodes || !treeNodes.length) return;
        var stack = [];
        //先将第一层节点放入栈
        for (var i = 0, len = treeNodes.length; i < len; i++)stack.push(treeNodes[i]);
        var item;
        while (stack.length) {
            item = stack.shift();
            //  await sleep();
            console.log(item.id);

            //如果该节点有子节点,继续添加进入栈底
            if (item.children && item.children.length)stack = stack.concat(item.children);
        }
        };
        
    
    console.timeEnd('------------- 非递归广度优先实现 ------------------');

    //非递归深度优先实现
    console.time('------------- 非递归深度优先实现 ------------------');
    var iterator2 = function (treeNodes) {
        if (!treeNodes || !treeNodes.length) return;
        var stack = [];
        //先将第一层节点放入栈
        for (var i = 0, len = treeNodes.length; i < len; i++)stack.push(treeNodes[i]);
        var item;
        while (stack.length) {
            item = stack.shift();
            console.log(item.id);
            //如果该节点有子节点,继续添加进入栈顶
            if (item.children && item.children.length) {
                stack = item.children.concat(stack);
            }
        }
    };

    
    console.timeEnd('------------- 非递归深度优先实现 ------------------');


    var treeNodes = [
        {
            id: 1,
            name: '1',
            children: [
                {
                    id: 11,
                    name: '11',
                    children: [
                            {
                                id: 111,
                                name: '111',
                                children:[]
                            },
                            {
                                id: 112,
                                name: '112',
                                children:[
                                                    
                                ]
                            }
                    ]
                },
                {
                    id: 12,
                    name: '12',
                    children: []
                },
                {
                    id: 13,
                    name: '13',
                    children: [
                        {
                            id: 131,
                            name: '131',
                            children: [
                                {
                                    id: 1311,
                                    name: '1311',
                                    children: []
                            }
                            ]
                    }
                    ]
                }
            ],
            users: []
        },
        
    ];
    // parseTreeJson(treeNodes);
    // iterator1(treeNodes);
    // iterator2(treeNodes);

相关

  • LazyMan 链式调用实现:手写实现中队列的用法
最近更新: 2026/10/12 09:08
Contributors: liujw
Prev
LazyMan 链式调用
Next
返回顶部 ToTop