Javascript 二叉树的最小深度并非适用于所有测试用例

我试图找到二叉树的最小深度；然而，我在示例5中的测试用例失败了。我不确定我的逻辑中是否存在缺陷，以使其适用于所有测试用例。我正在做的一个例子如下：

Example:
Given binary tree [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

return its minimum:
depth = 2

我有以下代码来实现这一点：

class TreeNode {
  constructor(val) {
    this.val = val;
    this.left = this.right = null;
  }
}

const minDepth = root => {
  if (!root) return 0

  const traverse = root => {
    let counter = 1
    if (!root) return counter
    let current
    let queue = [root, 's']

    while (queue.length > 1) {
      current = queue.shift()
      if (current === 's') counter++, queue.push('s')
      if (!current.left && !current.right) return counter
      else {
        if (current.left) queue.push(current.left)
        if (current.right) queue.push(current.right)
      }
    }
    return counter
  }
  return root.left && root.right ? Math.min(traverse(root.left), traverse(root.right)) + 1 : traverse(root)
}

//example 1  
const tree1 = new TreeNode(3)
tree1.left = new TreeNode(9)
tree1.right = new TreeNode(20)
tree1.right.left = new TreeNode(15)
tree1.right.right = new TreeNode(7)

//example 2
const tree2 = new TreeNode(1)
tree2.left = new TreeNode(2)
tree2.right = new TreeNode(3)
tree2.left.left = new TreeNode(4)
tree2.right.right = new TreeNode(5)

//example 3
const tree3 = new TreeNode(0)

//example 4
const tree4 = new TreeNode(1)
tree4.left = new TreeNode(2)

//example 5 not working
const tree5 = new TreeNode(1)
tree5.left = new TreeNode(2)
tree5.left.right = new TreeNode(3)
tree5.left.right.right = new TreeNode(4)
tree5.left.right.right.right = new TreeNode(5)


console.log(minDepth(tree1))
console.log(minDepth(tree2))
console.log(minDepth(tree3))
console.log(minDepth(tree4))
console.log(minDepth(tree5))

---

关于我遗漏了什么，有什么想法吗？

我有点不确定你的总体方法。您的函数似乎已设置为执行递归，但随后您将在嵌套函数中迭代工作。这两种方法对我来说都很有意义（递归似乎更容易），但我建议明确地使用其中一种方法

如果您确实选择了迭代，基本上您会运行一个并在到达第一个叶节点时停止。叶节点是没有子节点的节点，我们也需要检测递归的这种情况

递归只是为每个叶向上传递1。否则，当前节点为内部节点；为其添加1，并向上传递其子级的最小递归次数（通过合并无穷大的值忽略任何不存在的值）

const minDepth=root=>{
如果（！root）{
返回0；
}
else如果（！root.left&&！root.right）{
返回1；
}
返回1+Math.min（minDepth（root.left）| |无穷大，
minDepth（根.右）| |无穷大）；
};
三烯类{
构造函数（val）{
this.val=val；
this.left=null；
this.right=null；
}
}
/*
3.
/ \
9   20
/ \
15   7
应该是2
*/
const tree1=新的TreeNode（3）；
tree1.left=新的TreeNode（9）；
tree1.right=新的TreeNode（20）；
tree1.right.left=新的TreeNode（15）；
tree1.right.right=新的TreeNode（7）；
/*
1.
/ \
2   3
/     \
4       5
应该是3
*/
const tree2=新的TreeNode（1）；
tree2.left=新的TreeNode（2）；
tree2.right=新的TreeNode（3）；
tree2.left.left=新的TreeNode（4）；
tree2.right.right=新的TreeNode（5）；
/*
0
应该是1
*/
常数tree3=新TreeNode（0）；
/*
1.
/
2.
应该是2
*/
const tree4=新的TreeNode（1）；
tree4.left=新的TreeNode（2）；
/*
1.
/
2.
\ 
3.
\
4.
\
5.
应该是5岁
*/
常数tree5=新TreeNode（1）；
tree5.left=新的TreeNode（2）；
tree5.left.right=新的TreeNode（3）；
tree5.left.right.right=新树节点（4）；
树5.left.right.right.right=新树节点（5）；
console.log（minDepth（tree1））；
console.log（minDepth（tree2））；
console.log（minDepth（tree3））；
console.log（minDepth（tree4））；
控制台日志（minDepth（tree5））为什么要使用复杂的
遍历
函数来处理循环、队列和哨兵值？一个简单的递归函数就足够了。