js实现深度优先遍历和广度优先遍历

提出需求

今天逛公司文档发现有一道面试题，有下面一个对象，通过深度优先遍历和广度优先遍历查找到某一个节点的值

var tree = {
      name: "中国",
      children: [
        {
          name: "北京",
          children: [
            {
              name: "朝阳群众",
            },
            {
              name: "海淀区",
            },
            {
              name: "昌平区",
            },
          ],
        },
        {
          name: "浙江省",
          children: [
            {
              name: "杭州市",
              code: 0571,
            },
            {
              name: "嘉兴市",
            },
            {
              name: "绍兴市",
            },
            {
              name: "宁波市",
            },
          ],
        },
      ],
    };

深度优先遍历（递归和非递归）

利用了栈的特性（先入后出，js可用push，pop模拟）

首先是将根结点压入栈中；
利用循环，当栈内不为空时，每次取出一个结点出来操作；
在根结点取出后，将其左右子结点先后压入栈中；
再次循环后，被取出的就是后压入栈中的右子结点，而后再次将其左右子结点压入栈中；
再次循环时，被取出的还是右子结点的数据，直到叶子结点；
再次循环，被取出的是与叶子节点最近的左子结点；
遍历左子结点时，当遇到层级与已有右子结点相同的忽略，遇到新的层级时，将数据放入结果数组中；
…一直遍历到最后一个叶子结点为止。
代码实现：

 // 实现一个深度优先搜索算法（非递归）
    function dfs(tree, name) {
      // 请在这里实现
      let res = [];
      if (tree) {
        let stack = [];
        //利用栈特性先进后出
        stack.push(tree);
        while (stack.length !== 0) {
          let item = stack.pop();
          res.push(item);
          if (item.children) {
            for (let i = item.children.length - 1; i >= 0; i--) {
              stack.push(item.children[i]);
            }
          }
        }
      }
      console.log('dfs',res);

      return res.find((i) => i.name === name);
    }

 // 实现一个深度优先搜索算法（递归）
    function dfs(tree, name) {
      let res = [];
      function deepTraversal(tree) {
        if (tree) {
          res.push(tree);
          if (tree.children) {
            for (let i = 0; i < tree.children.length; i++) {
              deepTraversal(tree.children[i]);
            }
          }
        }
      }
      deepTraversal(tree);
      console.log('dfs',res);
      return res.find((i) => i.name === name);
    }
	var dfs = dfs(tree, "杭州市");
    console.log(bfs); // { name: '杭州市', code: 0571 }

两者的结果都一样：

广度优先遍历（非递归）

利用队列（先进先出，js可用push，shift模拟）

首先将根结点放入队列中；
利用循环，当队列不为空时，每次取出一个结点出来操作；
在根结点取出后，将其结点先后放入队列中；
再次循环后，依次将其左子结点，右子结点拿出，并对应将其左右子结点放入队列；
由于是先进先出，所以整个遍历过程后按照树的层级从上到下，从左至右依次遍历；
代码实现：

// 实现一个广度优先搜索算法（非递归）
    function bfs(tree, name) {
      let res = [];
      if (tree) {
        let queue = [];
        //利用队列特性先进先出
        queue.unshift(tree);
        while (queue.length !== 0) {
          let item = queue.shift();
          res.push(item);
          if (item.children) {
            for (let i = 0; i < item.children.length; i++) {
                queue.push(item.children[i]);
            }
          }
        }
      }
      console.log('bfs',res);

      return res.find((i) => i.name === name);
    }
    var bfs = bfs(tree, "杭州市");
     console.log(bfs); // { name: '杭州市', code: 0571 }

输出结果符合预期：