我的意思是在一个特定的水平，没有达到特定水平。可能有人请检查我的修改BFS算法？ （其中大部分是来自维基百科）

 队列levelorder（根，levelRequested）{
      INT currentLevel = 0;
      Q =空队列
q.enqueue（根）
而不是q.empty做{
如果（currentLevel == levelRequested）
                 返回q;
           节点：= q.dequeue（）
访问（节点）
           如果（node.left！= NULL || node.right！= NULL）{
                 currentLevel ++;
如果node.left≠空
q.enqueue（node.left）
如果node.right≠空
q.enqueue（node.right）
           }
      }
}
 

解决方案

我觉得一个递归解决方案会更简洁：

  / *
 *节点 - 节点被访问
 * clevel  - 目前的水平
 * rlevel  - 请求的级别
 *结果 - 结果队列
 * /
钻（节点，clevel，rlevel，结果）{
  如果（clevel == rlevel）{
    result.enqueue（节点）;
  其他 {
    如果（node.left！= NULL）
      钻（node.left，clevel + 1，rlevel，结果）;
    如果（node.right！= NULL）
      钻（node.right，clevel + 1，rlevel，结果）;
  }
}
 

初​​始调用看起来像：钻（根，O，N，rqueue）;

I mean on a specific level, NOT up to that specific level. Could someone please check my modified BFS algorithm? (most of which is taken from Wikipedia)

Queue levelorder(root, levelRequested){
      int currentLevel = 0;
      q = empty queue
      q.enqueue(root)
      while not q.empty do{
           if(currentLevel==levelRequested)
                 return q;
           node := q.dequeue()
           visit(node)
           if(node.left!=null || node.right!=null){
                 currentLevel++;
                 if node.left ≠ null
                       q.enqueue(node.left)
                 if node.right ≠ null
                       q.enqueue(node.right)
           }
      }
}

I think a recursive solution would be much more concise:

/*
 * node - node being visited
 * clevel - current level
 * rlevel - requested level
 * result - result queue
 */
drill (node, clevel, rlevel, result) {
  if (clevel == rlevel) {
    result.enqueue (node);
  else {
    if (node.left != null)
      drill (node.left, clevel + 1, rlevel, result);
    if (node.right != null)
      drill (node.right, clevel + 1, rlevel, result);
  }
}

Initial invocation would look like: drill (root, 0, n, rqueue);