树的深度#

 const tree ={
      value: 1,
      left: {
        value: 2,
        left: { value: 4 },
        right: { value: 5 },
      },
      right: {
        value: 3,
        left: { value: 6, right: { value: 7 } },
      },
    }
  // 调用 dfs(tree)
    const dfs =  (root) => {
        //函数的返回值记录了层数
        if (!root) {
          return 0
        } else {
          const left = dfs(root.left)
          const right = dfs(root.right)
          return Math.max(left, right) + 1
        }
      }
 
 //非递归 // 调用 maxDepth(tree) 
 
   const maxDepth =(root) => {
      let res = 0
      const dfs = (n, l) => {
        if (!n) {
          return
        }
        if (!n.left && !n.right) {
          res = Math.max(res, l)
        }
        dfs(n.left, l + 1)
        dfs(n.right, l + 1)
      }
      dfs(root, 1)
      return res
    }

 //N叉树
let  arr1Tree={
      value: 1,
      children: [
        {
          value: 3,
          children: [{ value: 5 }, { value: 6 }],
        },
        {
          value: 2,
          children: [{ value: 8, children: [{ value: 12 }] }],
        },
        {
          value: 4,
          children: [
            { value: 9, children: [{ value: 11 }] },
            { value: 10, children: [{ value: 13 }] },
          ],
        },
        {
          value: 7,
          children: [{ value: 16 }, { value: 17 }, { value: 18 }],
        },
      ],
    }
    
    // 广度遍历 --- 使用栈  quMaxDepth(arr1Tree)
    const quMaxDepth = (root) => {
      if (!root) {
        return 0
      }
      const queue = []
      queue.push(root)
      let ans = 0
      while (queue.length) {
        let size = queue.length
        while (size > 0) {
          const node = queue.shift()
          const children = node.children
          if (children) {
            for (const child of children) {
 
              queue.push(child)
            }
          }
          size = size - 1
        }
        ans = ans + 1
      }

      return ans
  }