Java广度优先搜索漂亮的印刷品

Question

This is my code for breadth-first-search. I'd like to print level by level. One line, one level.

public static void printTreeBreadthFirst(Tree t)
{
    Node root = t.getRoot();
    Queue<Node> queue = new LinkedList<Node>() ;
        if (root == null)
            return;
        queue.clear();
        queue.add(root);
        while(!queue.isEmpty()){
            Node<?> node = queue.remove();
            System.out.println(node.getData() + " ");
            if(node.getChildren().isEmpty())
                continue;
            else
                queue.addAll(node.getChildren());
        }
}

But, this is not a nice print since it prints everything on the same line. How can I implement this nice print?

EDIT: example of a nice print INPUT: (root (child1 (child 1.1, child 1.2) (child 2 (child 2.1)) (child3)) NICE output:

root                           (level 1)
child1 - child2 - child3       (level 2)
child1.1 - child1.2 - child2.1 (level 3)

Answer 1

To get the desired "nice print", you are missing the level when you pull a node out of the queue. Therefore you must create a new structure which you'll insert into the Queue, eg

class NodeLevel {
    private Node node;
    private int level;
    // ... constructor, getters, ...
}

And each time you add new elements to the queue, you use current level + 1 .

So, first insert root with level 1:

queue.add(new NodeList(root, 1));

When you remove element from queue, save the level:

NodeList nodeList = queue.remove();
Node<?> node = nodeList.getNode();
int level = nodeList.getLevel();
// pretty print using the node & level

And add new children with level + 1 :

node.getChildren().forEach(child -> queue.add(new NodeList(child, level + 1))); 

Or you can simply increase the level when you retrieve it from NodeList , so you don't do the addition in every iteration:

int childLevel = nodeList.getLevel() + 1;
//pretty print

Answer 2

The complicated part is to know when a given level ends. Nodes do not (typically) know their level, but can find it out by counting how many ancestors they have:

public static void getLevel(Node n) {
   return n == null ? 0 : 1 + getLevel(n.getParentNode());
}

Another, more efficient way to calculate these levels is to store it in the nodes themselves, and store these extended nodes in the Queue :

public class NodeWithLevel {
   private Node node;
   private int level;
   ...
}

Now you just have to change your printing code to check the level. If the level is increased, then you should skip a line:

int currentLevel = 0; // level of root
while (...) {
   ...
   System.out.print(node.getData() + " - ");
   if (getLevel(node) > currentLevel) {
       currentLevel ++;
       System.out.println(" (level " + currentLevel + ")");
   }
   if(node.getChildren().isEmpty())
   ...
}

This is not exactly what you asked for, but it is close. To remove the last " - " and align the levels, you would need to store the whole lines before you print them, and check the length of the longest line before generating any output.