Print level order traversal line by line
Last Updated :
01 Oct, 2024
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
[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 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 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# 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 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(" "));
}
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:
Similar Reads
Level order traversal line by line (Using One Queue) Given a Binary Tree, the task is to print the nodes level-wise, each level on a new line.Example:Input:Output:12 34 5Table of Content[Expected Approach – 1] Using Queue with delimiter – O(n) Time and O(n) Space[Expected Approach – 2] Using Queue without delimiter – O(n) Time and O(n) Space[Expected
12 min read
Level order traversal line by line (Using Two Queues) Given a Binary Tree, the task is to print the nodes level-wise, each level on a new line.Example: Input:Output:12 34 5Approach:The idea is to use two queues to traverse in Level order manner. We will insert the first level in first queue and print it and while popping from the first queue insert its
9 min read
Reverse Level Order Traversal Given a binary tree, the task is to find its reverse level order traversal. The idea is to print the last level first, then the second last level, and so on. Like Level order traversal, every level is printed from left to right.Examples: Input: Output:4 52 31Table of Content[Naive Approach] Using Re
15+ min read
Morris traversal for Inorder Given a Binary Tree, the task is to print its Inorder Traversal, without using recursion or stack.Examples:Input:Output: [4, 2, 5, 1, 3]Explanation: Inorder traversal (Left->Root->Right) of the tree is 4, 2, 5, 1, 3.Input:Output: [1, 7, 10, 8, 6, 10, 5, 6]Explanation: Inorder traversal (Left-
9 min read
Print Binary Tree levels in sorted order Given a Binary tree, the task is to print its all level in sorted order Examples: Input : 7 / \ 6 5 / \ / \ 4 3 2 1Output : 75 61 2 3 4 Input : 7 / \ 16 1 / \ 4 13 Output :7 1 164 13Recommended PracticePrint Binary Tree levels in sorted orderTry It!Here we can use two Priority queue for print in sor
9 min read