遍历算法

const tree = [
   {
     value: 1,
     children: [
       {
         value: 2,
         children: [{ value: 4 }, { value: 5 }]
       },
       {
         value: 10,
         children: [{ value: 11 }, { value: 12 }]
       },
       {
         value: 3,
         children: [
           {
             value: 6,
             children: [{ value: 7 }, { value: 8 }]
           },
           { value: 9 }
         ]
       }
     ]
   }
]

深度优先遍历：

深度优先搜索算法将会从第—个指定的顶点开始遍历图，沿着路径直到这条路径最后被访问了，接着原路回退并探索条路径。

function dfs(arr, handler) {
  arr.forEach(item => {
    handler(item.value)
    if (item.children) {
      dfs(item.children, handler);
    }
  })
}

广度优先遍历：

广度优先算法会从指定的第一个顶点开始遍历图，先访问其所有的相邻点，就像一次访问图的一层。
换句话说，就是先宽后深的访问顶点。

function bfs(arr, handler) {
  while (arr.length) {
    let temp = arr.shift();
    handler(temp.value);
    if (temp.children) {
      temp.children.forEach(item => {
        arr.push(item);
      })
    }
  }
}

模拟二叉树结构：

const node = {
  root: {
    key: 11,
    left: {
      key: 7,
      left: {
        key: 5,
        left: {
          key: 3,
        },
        right: {
          key: 6,
        }
      },
      right: {
        key: 9,
        left: {
          key: 8,
        },
        right: {
          key: 10,
        }
      }
    },
    right: {
      key: 15,
      left: {
        key: 13,
        left: {
          key: 12,
        },
        right: {
          key: 14,
        }
      },
      right: {
        key: 20,
        left: {
          key: 18,
          right: {
            key: 19,
          }
        },
        right: {
          key: 25,
        }
      }
    }
  }
}

前序遍历：

function prevSearch(node) {
  let resultString1 = '';
  prevSearchNode(node.root, (v) => {
    resultString1 += v + ' '
  })
  console.log(resultString1)
}

function prevSearchNode(node, handler) {
  if (node) {
    handler(node.key);
    prevSearchNode(node.left, handler);
    prevSearchNode(node.right, handler);
  }
}