Java 通用树的级别顺序树遍历，逐级显示树

我想逐级显示树结构。我当前的代码执行BFS或级别顺序遍历，但我无法让输出像树一样显示树结构 请参阅当前输出和预期输出

我的想法是使用某种计数来迭代队列中同一级别的元素

我怎么能这样做呢

如果有人需要整个实现，可以在下面的链接中找到没有此函数的原始代码。其他人只需查看下面的displayBFS函数

谢谢

   void displayBFS(NaryTreeNode n)
   {
      Queue<NaryTreeNode> q  = new LinkedList<NaryTreeNode>();
      System.out.println(n.data);

       while(n!=null)
     {   
         for(NaryTreeNode x:n.nary_list)
         {
             q.add(x);
             System.out.print(x.data + " ");
         }
         n=q.poll();
         System.out.println();
      } 
  }

Current Tree Structure for reference:

         root(100)
        /      |       \
      90       50       70
      /        \
    20 30   200  300


    Current Output:
        100
        90 50 70
        20 30
        200 300

    Expected Output
        100
        90 50 70
        20 30 200 300    

void displayBFS（奈米绿节点n）
{
队列q=新的LinkedList（）；
系统输出打印项次（n.数据）；
while（n！=null）
{   
用于（NaryTreeNode x:n.nary_列表）
{
q、 加（x）；
系统输出打印（x.data+“”）；
}
n=q.poll（）；
System.out.println（）；
} 
}
当前树结构供参考：
根（100）
/      |       \
90       50       70
/        \
20 30   200  300
电流输出：
100
90 50 70
20 30
200 300
预期产量
100
90 50 70
20 30 200 300    

---

另外，我之前发布了一个具有相同功能的逻辑问题，因为已经回答了这个问题，并且当前问题与另一个问题相关，我发布了一个新问题，这种方法可以吗，或者我应该编辑先前的问题而不打开新问题？

使用另一个队列来指示深度。 下面的代码未经测试，但它应该能让您了解这一点（引入sep变量是为了避免尾随空格）：

void displayBFS（奈米绿节点n）{
队列q=新的LinkedList（）；
队列深度=新建LinkedList（）；
q、 添加（n）；
深度。添加（0）；
字符串sep=“”；
int oldDepth=0
而（！q.isEmpty（））{
NaryTreeNode currN=q.poll（）；
int currDepth=depth.poll（）；
如果（currDepth>oldDepth）{
System.out.println（）；
oldDepth=当前深度；
sep=“”；
}
系统输出打印（九月+当前数据）；
sep=“”；
对于（NaryTreeNode x：当前列表）{
q、 加（x）；
深度。添加（currDepth+1）；
}
}
}

---

就我的口味而言，与其他方法相比，这种方法更容易解释。

只需跟踪当前级别和下一级别

static void displayBFS(NaryTreeNode root) {
    int curlevel = 1;
    int nextlevel = 0;

    LinkedList<NaryTreeNode> queue = new LinkedList<NaryTreeNode>();
    queue.add(root);

    while(!queue.isEmpty()) { 
        NaryTreeNode node = queue.remove(0);

        if (curlevel == 0) {
            System.out.println();
            curlevel = nextlevel;
            nextlevel = 0;
        }

        for(NaryTreeNode n : node.nary_list) {
            queue.addLast(n);
            nextlevel++;
        }

        curlevel--;
        System.out.print(node.data + " ");
    } 
}

静态void displayBFS（narytreenoderoot）{
int curlevel=1；
int nextlevel=0；
LinkedList队列=新建LinkedList（）；
添加（根）；
而（！queue.isEmpty（））{
NaryTreeNode节点=queue.remove（0）；
if（curlevel==0）{
System.out.println（）；
curlevel=nextlevel；
nextlevel=0；
}
for（narytreenoden:node.nary_列表）{
queue.addLast（n）；
nextlevel++；
}
卷发--；
System.out.print（node.data+“”）；
} 
}

切换级别时，将nextlevel替换为currentlevel并重置nextlevel。我更喜欢这样简单，而不是保持一个完整的单独队列

---

上周我在接受微软的采访时问了这个问题。。。我在电话里感觉不太好。很感谢你研究它。

我想我们还需要三个变量。numInCurrentLevel用于跟踪当前级别中的元素数量，indexInCurrentLevel用于在当前级别中遍历时进行计数，NumInExtLevel用于跟踪下一级别中的元素数量。代码如下：

static void displayBFS(NaryTreeNode root) {

    Queue<NaryTreeNode> q  = new LinkedList<NaryTreeNode>();;
    q.add(root);
    int numInCurrentLevel = 1;
    int numInNextLevel = 0;
    int indexInCurrentLevel=0;

    while(!q.isEmpty()) { 
        NaryTreeNode node = q.poll();
        System.out.print(node.data + " ");
        indexInCurrentLevel++;

        for(NaryTreeNode n : node.nary_list) {
            q.add(n);
            numInNextLevel++;
        }

        //finish traversal in current level
        if(indexInCurrentLevel==numInCurrentLevel) {
            System.out.println();
            numInCurrentLevel=numInNextLevel;
            numInNextLevel=0;           
            indexInCurrentLevel=0;
        }
  } 
}

静态void displayBFS（narytreenoderoot）{
队列q=新的LinkedList（）；；
q、 添加（根）；
int numInCurrentLevel=1；
int numnextlevel=0；
int indexInCurrentLevel=0；
而（！q.isEmpty（））{
NaryTreeNode节点=q.poll（）；
System.out.print（node.data+“”）；
indexInCurrentLevel++；
for（narytreenoden:node.nary_列表）{
q、 添加（n）；
numInNextLevel++；
}
//在当前级别中完成遍历
if（indexInCurrentLevel==numInCurrentLevel）{
System.out.println（）；
numInCurrentLevel=numInNextLevel；
numInNextLevel=0；
indexInCurrentLevel=0；
}
} 
}

---

希望能有所帮助，我对java编程不太熟悉。

我所知道的解决这个问题的最简单方法是使用sentinel。使用根节点和sentinel初始化队列，然后在队列中循环：

拆下前滤芯

如果是哨兵：

• 我们在一个级别的末尾，所以我们可以结束输出行
• 如果队列不是空的，则将哨兵推回到末尾的队列上

如果不是哨兵：

• 打印出来
• 将其所有子对象推到队列中

我不做java，但是我有一些C++代码用于深度感知bfs，我把它拆开来做这个打印任务：

void show_tree_by_levels(std::ostream& os, Node* tree) {
  Node* sentinel = new Node;
  std::deque<Node*> queue{tree, sentinel};
  while (true) {
    Node* here = queue.front();
    queue.pop_front();
    if (here == sentinel) {
      os << std::endl;
      if (queue.empty())
        break;
      else
        queue.push_back(sentinel);
    } else {
      for (Node* child = here->child; child; child = child->sibling)
        queue.push_back(child);
      os << here->value << ' ';
    }
  }
}

void按级别显示树（std:：ostream&os，Node*tree）{
Node*sentinel=新节点；
std：：deque队列{tree，sentinel}；
while（true）{
Node*here=queue.front（）；
queue.pop_front（）；
如果（此处==哨兵）{
操作系统子级；子级；子级=子级->同级）
排队。推回（儿童）；
os值
void show_tree_by_levels(std::ostream& os, Node* tree) {
  Node* sentinel = new Node;
  std::deque<Node*> queue{tree, sentinel};
  while (true) {
    Node* here = queue.front();
    queue.pop_front();
    if (here == sentinel) {
      os << std::endl;
      if (queue.empty())
        break;
      else
        queue.push_back(sentinel);
    } else {
      for (Node* child = here->child; child; child = child->sibling)
        queue.push_back(child);
      os << here->value << ' ';
    }
  }
}

def printLevelWiseTree(tree):
q= queue.Queue()
if tree == None:
    return None
q.put(tree)
while (not(q.empty())):
    c = q.get()
    print(c.data,end=":")
    for i in range(len(c.children)):
        if i != len(c.children)-1:
            print(c.children[i].data,end=",")
        else:
            print(c.children[i].data,end="")
        q.put(c.children[i])
    print()