Print level order traversal line by line | Set 1

Given a binary tree, print level order traversal in a way that nodes of all levels are printed in separate lines.

For example consider the following tree

Example 1:
BST_LCA
Output for above tree should be
20
8 22
4 12
10 14

Example 2:
          1
       /     \
      2       3
    /   \       \
   4     5       6
        /  \     /
       7    8   9
Output for above tree should be
1
2 3
4 5 6
7 8 9<



Note that this is different from simple level order traversal where we need to print all nodes together. Here we need to print nodes of different levels in different lines.

A simple solution is to print use the recursive function discussed in the level order traversal post and print a new line after every call to printGivenLevel().

C++

/* Function to line by line print level order traversal a tree*/
void printLevelOrder(struct node* root)
{
    int h = height(root);
    int i;
    for (i=1; i<=h; i++)
    {
        printGivenLevel(root, i);
        printf("\n");
    }
}
  
/* Print nodes at a given level */
void printGivenLevel(struct node* root, int level)
{
    if (root == NULL)
        return;
    if (level == 1)
        printf("%d ", root->data);
    else if (level > 1)
    {
        printGivenLevel(root->left, level-1);
        printGivenLevel(root->right, level-1);
    }
}

Java

/* Function to line by line print level order traversal a tree*/
static void printLevelOrder(Node root)
{
    int h = height(root);
    int i;
    for (i=1; i<=h; i++)
    {
        printGivenLevel(root, i);
        System.out.println();
    }
}
/* Print nodes at a given level */
void printGivenLevel(Node root, int level)
{
    if (root == null)
        return;
    if (level == 1)
        System.out.println(root.data);
    else if (level > 1)
    {
        printGivenLevel(root.left, level-1);
        printGivenLevel(root.right, level-1);
    }
}

The time complexity of the above solution is O(n2)

How to modify the iterative level order traversal (Method 2 of this) to levels line by line?
The idea is similar to this post. We count the nodes at current level. And for every node, we enqueue its children to queue.

C++

/* Iterative program to print levels line by line */
#include <iostream> 
#include <queue> 
using namespace std; 
  
// A Binary Tree Node 
struct node 
    struct node *left; 
    int data; 
    struct node *right; 
}; 
  
// Iterative method to do level order traversal
// line by line 
void printLevelOrder(node *root) 
    // Base Case 
    if (root == NULL) return
  
    // Create an empty queue for level order tarversal 
    queue<node *> q; 
  
    // Enqueue Root and initialize height 
    q.push(root); 
  
    while (q.empty() == false
    
        // nodeCount (queue size) indicates number
        // of nodes at current lelvel. 
        int nodeCount = q.size(); 
  
        // Dequeue all nodes of current level and 
        // Enqueue all nodes of next level 
        while (nodeCount > 0)
        
            node *node = q.front(); 
            cout << node->data << " "
            q.pop(); 
            if (node->left != NULL) 
                q.push(node->left); 
            if (node->right != NULL) 
                q.push(node->right); 
            nodeCount--; 
        
        cout << endl; 
    
  
// Utility function to create a new tree node 
node* newNode(int data) 
    node *temp = new node; 
    temp->data = data; 
    temp->left = NULL; 
    temp->right = NULL; 
    return temp; 
  
// Driver program to test above functions 
int main() 
    // Let us create binary tree shown above 
    node *root = newNode(1); 
    root->left = newNode(2); 
    root->right = newNode(3); 
    root->left->left = newNode(4); 
    root->left->right = newNode(5); 
    root->right->right = newNode(6); 
  
    printLevelOrder(root); 
    return 0; 
}

Java

/* An Iterative Java program to print levels line by line */
  
import java.util.LinkedList;
import java.util.Queue;
  
public class LevelOrder 
{
    // A Binary Tree Node
    static class Node
    {
        int data;
        Node left;
        Node right;
          
        // constructor
        Node(int data){
            this.data = data;
            left = null;
            right =null;
        }
    }
      
    // Iterative method to do level order traversal line by line
    static void printLevelOrder(Node root)
    {
        // Base Case
        if(root == null)
            return;
          
        // Create an empty queue for level order tarversal
        Queue<Node> q =new LinkedList<Node>();
          
        // Enqueue Root and initialize height
        q.add(root);
          
          
        while(true)
        {
              
            // nodeCount (queue size) indicates number of nodes
            // at current level.
            int nodeCount = q.size();
            if(nodeCount == 0)
                break;
              
            // Dequeue all nodes of current level and Enqueue all
            // nodes of next level
            while(nodeCount > 0)
            {
                Node node = q.peek();
                System.out.print(node.data + " ");
                q.remove();
                if(node.left != null)
                    q.add(node.left);
                if(node.right != null)
                    q.add(node.right);
                nodeCount--;
            }
            System.out.println();
        }
    }
      
    // Driver program to test above functions
    public static void main(String[] args) 
    {
        // Let us create binary tree shown in above diagram
       /*               1
                   /     \
                  2       3
                /   \       \
               4     5       6
        */
          
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.right = new Node(6);
          
        printLevelOrder(root);
  
    }
  
}
//This code is contributed by Sumit Ghosh


Output:

1
2 3
4 5 6

Time complexity of this method is O(n) where n is number of nodes in given binary tree.

Level order traversal line by line | Set 2 (Using Two Queues)

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above



My Personal Notes arrow_drop_up