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++

filter_none

edit
close

play_arrow

link
brightness_4
code

/* 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);
    }
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

/* 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);
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for above approach
  
def printlevelorder(root):
    h = height(root)
    for i in range(1, h + 1):
        givenspirallevel(root, i)
  
def printGivenLevel(root, level):
    if root is None:
        return root
      
    if level == 1:
        print(root.val, end = ' ')
    elif level > 1:
        printGivenLevel(root.left, level - 1)
        printGivenLevel(root.right, level - 1)
  
# This code is contributed by Praveen kumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

/* Print nodes at a given level */
static void printGivenLevel(Node root, int level)
{
    if (root == null)
        return;
    if (level == 1)
        Console.WriteLine(root.data);
    else if (level > 1)
    {
        printGivenLevel(root.left, level-1);
        printGivenLevel(root.right, level-1);
    }
}

chevron_right


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++

filter_none

edit
close

play_arrow

link
brightness_4
code

/* 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; 
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

/* 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for above approach
class newNode:
    def __init__(self, data):
        self.val = data 
        self.left = None
        self.right = None
          
# Iterative method to do level order traversal
# line by line
def printLevelOrder(root):
      
    # Base case
    if root is None:
        return
    # Create an empty queue for level order traversal
    q = []
      
    # Enqueue root and initialize height
    q.append(root)
          
    while q:
      
        # nodeCount (queue size) indicates number
        # of nodes at current lelvel.
        count = len(q)
          
        # Dequeue all nodes of current level and 
        # Enqueue all nodes of next level 
        while count > 0:
            temp = q.pop(0)
            print(temp.val, end = ' ')
            if temp.left:
                q.append(temp.left)
            if temp.right:
                q.append(temp.right)
  
            count -= 1
        print(' ')
          
# Driver Code
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);
  
# This code is contributed by Praveen kumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

/* An Iterative C# program to print 
levels line by line */
using System;
using System.Collections.Generic;
  
public class LevelOrder 
    // A Binary Tree Node 
    class Node 
    
        public int data; 
        public Node left; 
        public Node right; 
          
        // constructor 
        public 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 Queue<Node>(); 
          
        // Enqueue Root and initialize height 
        q.Enqueue(root); 
          
        while(true
        
              
            // nodeCount (queue size) indicates 
            // number of nodes at current level. 
            int nodeCount = q.Count; 
            if(nodeCount == 0) 
                break
              
            // Dequeue all nodes of current level 
            // and Enqueue all nodes of next level 
            while(nodeCount > 0) 
            
                Node node = q.Peek(); 
                Console.Write(node.data + " "); 
                q.Dequeue(); 
                if(node.left != null
                    q.Enqueue(node.left); 
                if(node.right != null
                    q.Enqueue(node.right); 
                nodeCount--; 
            
            Console.WriteLine(); 
        
    
      
    // Driver Code
    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 29AjayKumar

chevron_right



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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up