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



My Personal Notes arrow_drop_up