JS 深度优先遍历与广度优先遍历 实现查找

 

2.1.深度优先遍历
深度优先查找（depth first search），采用栈结构，后进先出，JS用递归实现和没有用递归实现

// 不用递归实现深度遍历优先  
const depthFirstSearchWithoutRecursive = source => {
    const result = []; // 存放结果的数组
    // 当前栈内为全部数组
    const stack = JSON.parse(JSON.stringify(source));
    // 循环条件，栈不为空
    while (stack.length !== 0) {
      // 最上层节点出栈
      const node = stack.shift();
      // 存放节点
      result.push(node.id);
      // 如果该节点有子节点，将子节点存入栈中，继续下一次循环
      const len = node.children && node.children.length;
      for (let i = len - 1; i >= 0; i -= 1) {
        stack.unshift(node.children[i]);
      }
    }
    return result;
  };
 
  const s = depthFirstSearchWithoutRecursive(root)
  console.log(s);// 结果为 [1, 2, 4, 5, 7, 8, 6, 3]

 

2.2.广度优先遍历
广度优先查找（breadth first search），采用栈结构，后进先出，JS用递归实现和没有用递归实现

  const breadthFirstSearch = source => {
    const result = []; // 存放结果的数组
    // 当前队列为全部数据
    const queue = JSON.parse(JSON.stringify(source));
    // 循环条件，队列不为空
    while (queue.length > 0) {
      // 第一个节点出队列
      const node = queue.shift();
      // 存放结果数组
      result.push(node.id);
      // 当前节点有子节点则将子节点存入队列，继续下一次的循环
      const len = node.children && node.children.length;
      for (let i = 0; i < len; i += 1) {
        queue.push(node.children[i]);
      }
    }
    return result;
  };
 
  const s = breadthFirstSearch(root)
  console.log(s);// 结果为 [1, 2, 3, 4, 5, 6, 7, 8]

 

export const matchArea = function _matchArea(area: IArea[], content: string) {
  let matched: IArea[] = []
  if (!content || !area || !Array.isArray(area)) return matched

  area.forEach((item) => {
    if (content?.includes(item.name)) {
      matched.push(item)
    }
    if (item?.children) {
      const subMatch = _matchArea(item.children, content)
      matched = matched.concat(subMatch)
    }
  })
  return matched
}