简单介绍下广度优先遍历BFS和深度优先遍历DFS

深度优先遍历DFS和广度优先遍历BFS，通常用于树形结构的遍历，最常见的就是对Dom节点的遍历，用于对这个dom树进行查找，如下

深度优先遍历DFS

假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。深度遍历优先DFS有三种实现方式，两种递归，一种非递归

let deepTraversal1 = (node, nodeList = []) => {
  if (node !== null) {
    nodeList.push(node)
    let children = node.children
    if(children.length) {
      for (let i = 0; i < children.length; i++) {
        deepTraversal1(children[i], nodeList)
      }
    }
  }
  return nodeList
}
let deepTraversal2 = (node) => {
    let nodeList = []
    if (node !== null) {
      nodeList.push(node)
      let children = node.children
      if(children.length) {
         for (let i = 0; i < children.length; i++) {
          // 分而治之，拆和并
          nodeList = nodeList.concat(deepTraversal2(children[i]))
        }
      }
    }
    return nodeList
  }
  // 非递归
let deepTraversal3 = (node) => {
  // 定义堆栈的数据结构，先进后出(后序遍历)
  let stack = []
  // 定义结果容器
  let nodeList = []
  if (node) {
    // 推入当前处理的node
    stack.push(node)
    while (stack.length) {
      // 后出
      let item = stack.pop()
      nodeList.push(item)
      let children = item.children
      if(children.length) {
        for (let i = children.length - 1; i >= 0; i--) {
          // 先进
          stack.push(children[i])
        }
      }
    }
  }
  return nodeList
}

上面第二个递归方法deepTraversal2使用了分治思想，顾名思义，分而治之，就是把一个问题拆成若干个小问题，小问题再进一步拆解成若干个小问题，一直到问题足够简单，得出结果，再由子结果不断向上归并成为最后的结果。

广度优先遍历BFS

从图中某顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使得“先被访问的顶点的邻接点先于后被访问的顶点的邻接点被访问，直至图中所有已被访问的顶点的邻接点都被访问到。如果此时图中尚有顶点未被访问，则需要另选一个未曾被访问过的顶点作为新的起始点，重复上述过程，直至图中所有顶点都被访问到为止。

let widthTraversal2 = (node) => {
  let nodes = []
  // 队列，先进先出
  let queue = []
  if (node) {
    queue.push(node)
    while (queue.length) {
      // 先进
      let item = queue.shift()
      nodes.push(item)
      let children = item.children
      if(children.length) {
        for (let i = 0; i < children.length; i++) {       
          // 先出
          queue.push(children[i])
        }
      }
    }
  }
  return nodes
}

应用: 递归树形数据查询该节点的所有父级节点、查询该节点的所有子节点等

示例：

const data = [
         {
          id: 1,
          label: '一级 1',
          children: [{
            id: 4,
            label: '二级 1-1',
            children: [{
              id: 9,
              label: '三级 1-1-1'
            }, {
              id: 10,
              label: '三级 1-1-2'
            }]
          }]
        }, 
        {
          id: 2,
          label: '一级 2',
          children: [{
            id: 5,
            label: '二级 2-1'
          }, {
            id: 6,
            label: '二级 2-2'
          }]
        }, 
        {
          id: 3,
          label: '一级 3',
          children: [{
            id: 7,
            label: '二级 3-1'
          }, {
            id: 8,
            label: '二级 3-2'
          }]
        }];

根据ID获取该节点的所有父节点的对象

function getParentId(list,id) {
        for (let i in list) {
            if(list[i].id==id){
            return [list[i]]
          }
          if(list[i].children){
            let node=getParentId(list[i].children,id);
            if(node!==undefined){
                return node.concat(list[i])
               }
          }
        }        
}
console.log(getParentId(data,10)) // 打印出来就是想要的数据

根据ID获取该节点的对象

function getId(list,id) {
        for (let i in list) {
            if(list[i].id==id){
            return [list[i]]
          }
          if(list[i].children){
            let node=getParentId(list[i].children,id);
            if(node!==undefined){
                return node;
               }
          }
        }    
 }
 console.log(getId(data,4)) // 打印出来就是想要的数据