Open In App

Print level order traversal line by line

Last Updated : 23 Jul, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given a Binary Tree, the task is to print the nodes level-wise, each level on a new line.

Example:

Input:

Output:
1
2 3
4 5

Table of Content

[Naive Approach] - Using Recursion - O(n^2) Time and O(n) Space

A simple solution to perform level order traversal is to first calculate the height of the tree. After obtaining the height, we can use a recursive function to store the nodes at each level into a container. For each level from 1 to the height, we traverse the tree using depth-first search while maintaining the current height. Instead of printing the nodes directly, we store them in a 2d container, where each inner corresponds to a level in the tree.

Below is the implementation of the above approach:

C++ 
// C++ Program to print level Order
// traversal of Binary Tree
#include <bits/stdc++.h>
using namespace std;

class Node {
  public:
    int data;
    Node *left, *right;

    Node(int key) {
        data = key;
        left = nullptr;  
        right = nullptr; 
    }
};

// Print nodes at a given level
void printGivenLevel(Node *root, int level, vector<int> &levelNodes) {
    if (root == nullptr)
        return;
    if (level == 1) {
        levelNodes.push_back(root->data);
    }
    else if (level > 1) {
        printGivenLevel(root->left, level - 1, levelNodes);
        printGivenLevel(root->right, level - 1, levelNodes);
    }
}

// Compute the "height" of a tree -- the number of
// nodes along the longest path from the root node
// down to the farthest leaf node.
int height(Node *node) {
    if (node == nullptr)
        return 0;

    // Compute the height of each subtree
    int lheight = height(node->left);
    int rheight = height(node->right);

    // Use the larger one without the ternary operator
    if (lheight > rheight) {
        return lheight + 1;
    }
    else {
        return rheight + 1;
    }
}

// Function to return level order traversal as 
// a vector of vectors
vector<vector<int>> levelOrder(Node *root) {
    vector<vector<int>> result;
    int h = height(root);
    for (int i = 1; i <= h; i++) {
        vector<int> levelNodes;
        printGivenLevel(root, i, levelNodes);
        result.push_back(levelNodes);
    }
    return result;
}


int main() {

    // Binary Tree Representation
    //
    //       1
    //     /   \
    //    2     3
    //   / \
    //  4   5

    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);

    vector<vector<int>> result = levelOrder(root);
    for (const auto &level : result) {
        for (int val : level) {
            cout << val << " ";
        }
        cout << endl;
    }

    return 0;
}
Java 
// Java Program to print level Order
// traversal of Binary Tree

import java.util.ArrayList;
import java.util.List;

class Node {
    int data;
    Node left, right;

    Node(int key) {
        data = key;
        left = null;
        right = null;
    }
}

class GfG {
  
    // Compute the "height" of a tree -- the number of
    // nodes along the longest path from the root node
    // down to the farthest leaf node.
    static int height(Node node) {
        if (node == null)
            return 0;
        else {
          
            // compute the height of each subtree
            int lheight = height(node.left);
            int rheight = height(node.right);

            // use the larger one
            return Math.max(lheight, rheight) + 1;
        }
    }

    static void printGivenLevel(Node root, int level,
                                List<Integer> levelNodes) {
        if (root == null)
            return;
        if (level == 1)
            levelNodes.add(root.data);
        else if (level > 1) {
            printGivenLevel(root.left, level - 1, levelNodes);
            printGivenLevel(root.right, level - 1, levelNodes);
        }
    }

    // Function to return level order traversal as a list of
    // lists
    static List<List<Integer> > levelOrder(Node root) {
        List<List<Integer> > result = new ArrayList<>();
        int h = height(root);
        for (int i = 1; i <= h; i++) {
            List<Integer> levelNodes = new ArrayList<>();
            printGivenLevel(root, i, levelNodes);
            result.add(levelNodes);
        }
        return result;
    }

    public static void main(String[] args) {

        // Binary Tree Representation
        //
        //       1
        //     /   \
        //    2     3
        //   / \
        //  4   5

        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);
      
        List<List<Integer> > result = levelOrder(root);

        for (List<Integer> level : result) {
            for (int val : level) {
                System.out.print(val + " ");
            }
            System.out.println();
        }
    }
}
Python 
# Python Program to print level Order
# traversal of Binary Tree
class Node:
    def __init__(self, key):
        self.data = key
        self.left = None
        self.right = None


def height(node):
    if node is None:
        return 0
    else:
      
        # compute the height of each subtree
        lheight = height(node.left)
        rheight = height(node.right)

        # use the larger one
        return (lheight + 1) if lheight > rheight else (rheight + 1)


def printGivenLevel(root, level, levelNodes):
    if root is None:
        return
    if level == 1:
        levelNodes.append(root.data)
    elif level > 1:
        printGivenLevel(root.left, level - 1, levelNodes)
        printGivenLevel(root.right, level - 1, levelNodes)


def levelOrder(root):
    result = []
    h = height(root)
    for i in range(1, h + 1):
        levelNodes = []
        printGivenLevel(root, i, levelNodes)
        result.append(levelNodes)
    return result

# Binary Tree Representation
#
#       1
#     /   \
#    2     3
#   / \
#  4   5

root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)

result = levelOrder(root)

for level in result:
    for val in level:
        print(val, end=" ")
    print()
C# 
// C# Program to print level Order traversal
// of Binary Tree

using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int key) {
        data = key;
        left = null;
        right = null;
    }
}

class GfG {
  
    // Compute the "height" of a tree -- the number of
    // nodes along the longest path from the root node
    // down to the farthest leaf node.
    static int Height(Node node) {
        if (node == null)
            return 0;
        else {
          
            // compute the height of each subtree
            int lheight = Height(node.left);
            int rheight = Height(node.right);

            // use the larger one
            return Math.Max(lheight, rheight) + 1;
        }
    }

    static void PrintGivenLevel(Node root, int level, 
                                List<int> levelNodes) {
        if (root == null)
            return;
        if (level == 1)
            levelNodes.Add(root.data);
        else if (level > 1) {
            PrintGivenLevel(root.left, level - 1, levelNodes);
            PrintGivenLevel(root.right, level - 1, levelNodes);
        }
    }

    // Function to return level order traversal 
  	// as a list of lists
    static List<List<int>> LevelOrder(Node root) {
        List<List<int>> result = new List<List<int>>();
        int h = Height(root);
        for (int i = 1; i <= h; i++) {
            List<int> levelNodes = new List<int>();
            PrintGivenLevel(root, i, levelNodes);
            result.Add(levelNodes);
        }
        return result;
    }

    static void Main() {
      
        // Binary Tree Representation
        //
        //       1
        //     /   \
        //    2     3
        //   / \
        //  4   5
        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);

        List<List<int>> result = LevelOrder(root);

        foreach (var level in result) {
            foreach (var val in level) {
                Console.Write(val + " ");
            }
            Console.WriteLine();
        }
    }
}
JavaScript 
// JavaScript Program to print level Order
// traversal of Binary Tree

class Node {
    constructor(key) {
        this.data = key;
        this.left = null;
        this.right = null;
    }
}

function height(node) {
    if (node === null) {
        return 0;
    } else {
    
        // compute the height of each subtree 
        const lheight = height(node.left);
        const rheight = height(node.right);

        // use the larger one 
        return Math.max(lheight, rheight) + 1;
    }
}

function printGivenLevel(root, level, levelNodes) {
    if (root === null) {
        return;
    }
    if (level === 1) {
        levelNodes.push(root.data);
    } else if (level > 1) {
        printGivenLevel(root.left, level - 1, levelNodes);
        printGivenLevel(root.right, level - 1, levelNodes);
    }
}

function levelOrder(root) {
    const result = [];
    const h = height(root);
    for (let i = 1; i <= h; i++) {
        const levelNodes = [];
        printGivenLevel(root, i, levelNodes);
        result.push(levelNodes);
    }
    return result;
}

// Binary Tree Representation
//
//       1
//     /   \
//    2     3
//   / \
//  4   5

const 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);

const traversal = levelOrder(root);
for (const level of traversal) {
    console.log(level.join(" "));
}

Output
1 
2 3 
4 5

Time complexity: O(n^2) where n is the number of node of binary tree.
Auxiliary Space: O(n), recursion stack space used is O(n).

[Expected Approach – 1] Using Queue with delimiter – O(n) Time and O(n) Space

The idea is to use single queues and delimiter to traverse in Level order manner. First insert the root and a null into the queue. NULL acts as a delimiter. Next, pop from the top of the queue and add its left and right nodes to the end of the queue and then add the top element of the queue into container. When we find the top element of the queue as NULL, it indicates the occurrence of next level. Continue this process till the queues become empty. Please refer to Level order traversal line by line (Using One Queue) for implementation.

[Expected Approach – 2] Using Queue without delimiter – O(n) Time and O(n) Space

To perform a level order traversal of a binary tree, use a queue to process nodes level by level. Start by enqueuing the root node, then iterate while the queue is not empty. For each level, determine the number of nodes to process, dequeue each node, store in the container , and enqueue its children. After processing all nodes at the current level, finally push the current level stored in the result before moving to the next level. Please refer to Level order traversal line by line (Using One Queue) for implementation.

Related articles:


Print level order traversal line by line | Set 1
Next Article
Analysis of Algorithms

K
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox