数组的递归调用，对广度优先和深度优先对比

一时失言乱红尘 2023-03-03 06:21 35阅读 0赞

// 测试数据
    var arr=[
      {
        id:1,
        chlid:[
          {
            id:11,
            chlid:[
              {
                id:111,
                chlid:[]
              },
              {
                id:112,
                chlid:[]
              }
            ]
          },
          {
            id:12,
            chlid:[]
          }
        ]
      },
      {
        id:2,
        chlid:[
          {
            id:21,
            chlid:[
              {
                id:211,
                chlid:[]
              },
              {
                id:212,
                chlid:[]
              }
            ]
          },
          {
            id:22,
            chlid:[]
          }
        ]
      },
      {
        id:3,
        chlid:[
          {
            id:31,
            chlid:[
              {
                id:311,
                chlid:[]
              },
              {
                id:312,
                chlid:[]
              }
            ]
          },
          {
            id:32,
            chlid:[]
          }
        ]
      }
    ]
    
    // 广度优先 BFS
    const bfsArr=[]
    function bfs(arr){
      const temp=[]
      arr.forEach(item=>{
      	bfsArr.push(item.id)
        if(item.chlid.length>0){
          temp.push(...item.chlid)
        }
      })
      temp.length>0&&bfs(temp)
    }
    bfs(arr)
    console.log(bfsArr)
    // [1, 2, 3, 11, 12, 21, 22, 31, 32, 111, 112, 211, 212, 311, 312]
    
    // 深度优先 DFS
    const dfsArr=[]
    function dfs(arr){
      arr.forEach(item=>{
      	dfsArr.push(item.id)
        if(item.chlid.length>0){
          dfs(item.chlid)
        }
      })
    }
    dfs(arr)
    console.log(dfsArr)
    // [1, 11, 111, 112, 12, 2, 21, 211, 212, 22, 3, 31, 311, 312, 32]