# Level Order Binary Tree Traversal

• Difficulty Level : Easy
• Last Updated : 22 Sep, 2022

Given the root of the Binary Tree. The task is to print the Level order traversal of a tree is breadth first traversal for the tree.

Input: Output:
1
2 3
4 5

Input: Output:
20
8 22
4 12
10 14

Recommended Practice

## Level Order Binary Tree Traversal using Recursion:

Below is the idea to solve the problem:

Print the level order traversal of the tree using recursive function to traverse all nodes of a level. Find height of tree and run depth first search and maintain current height, print nodes for every height from root and for 1 to height and match if the current height is equal to height of the iteration then print node’s data.

Follow the below steps to Implement the idea:

• Run a for loop for counter i, i.e. current height from 1 to h (height of the tree).
• Use DFS to traverse the tree and maintain height for the current node.
• If the Node is NULL then return;
• If level is 1 print(tree->data);
• Else if the level is greater than 1, then
• Recursively call to for tree->left, level-1.
• Recursively call to for tree->right, level-1.

Below is the implementation of the above approach:

## C++

 `// Recursive CPP program for level` `// order traversal of Binary Tree` `#include ` `using` `namespace` `std;`   `/* A binary tree node has data,` `pointer to left child` `and a pointer to right child */` `class` `node {` `public``:` `    ``int` `data;` `    ``node *left, *right;` `};`   `/* Function prototypes */` `void` `printCurrentLevel(node* root, ``int` `level);` `int` `height(node* node);` `node* newNode(``int` `data);`   `/* Function to print level` `order traversal a tree*/` `void` `printLevelOrder(node* root)` `{` `    ``int` `h = height(root);` `    ``int` `i;` `    ``for` `(i = 1; i <= h; i++)` `        ``printCurrentLevel(root, i);` `}`   `/* Print nodes at a current level */` `void` `printCurrentLevel(node* root, ``int` `level)` `{` `    ``if` `(root == NULL)` `        ``return``;` `    ``if` `(level == 1)` `        ``cout << root->data << ``" "``;` `    ``else` `if` `(level > 1) {` `        ``printCurrentLevel(root->left, level - 1);` `        ``printCurrentLevel(root->right, level - 1);` `    ``}` `}`   `/* 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 == NULL)` `        ``return` `0;` `    ``else` `{` `        ``/* compute the height of each subtree */` `        ``int` `lheight = height(node->left);` `        ``int` `rheight = height(node->right);`   `        ``/* use the larger one */` `        ``if` `(lheight > rheight) {` `            ``return` `(lheight + 1);` `        ``}` `        ``else` `{` `            ``return` `(rheight + 1);` `        ``}` `    ``}` `}`   `/* Helper function that allocates` `a new node with the given data and` `NULL left and right pointers. */` `node* newNode(``int` `data)` `{` `    ``node* Node = ``new` `node();` `    ``Node->data = data;` `    ``Node->left = NULL;` `    ``Node->right = NULL;`   `    ``return` `(Node);` `}`   `/* Driver code*/` `int` `main()` `{` `    ``node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->left->left = newNode(4);` `    ``root->left->right = newNode(5);`   `    ``cout << ``"Level Order traversal of binary tree is \n"``;` `    ``printLevelOrder(root);`   `    ``return` `0;` `}`   `// This code is contributed by rathbhupendra`

## C

 `// Recursive C program for level` `// order traversal of Binary Tree` `#include ` `#include `   `/* A binary tree node has data,` `   ``pointer to left child` `   ``and a pointer to right child */` `struct` `node {` `    ``int` `data;` `    ``struct` `node *left, *right;` `};`   `/* Function prototypes */` `void` `printCurrentLevel(``struct` `node* root, ``int` `level);` `int` `height(``struct` `node* node);` `struct` `node* newNode(``int` `data);`   `/* Function to print level order traversal a tree*/` `void` `printLevelOrder(``struct` `node* root)` `{` `    ``int` `h = height(root);` `    ``int` `i;` `    ``for` `(i = 1; i <= h; i++)` `        ``printCurrentLevel(root, i);` `}`   `/* Print nodes at a current level */` `void` `printCurrentLevel(``struct` `node* root, ``int` `level)` `{` `    ``if` `(root == NULL)` `        ``return``;` `    ``if` `(level == 1)` `        ``printf``(``"%d "``, root->data);` `    ``else` `if` `(level > 1) {` `        ``printCurrentLevel(root->left, level - 1);` `        ``printCurrentLevel(root->right, level - 1);` `    ``}` `}`   `/* 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(``struct` `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 */` `        ``if` `(lheight > rheight)` `            ``return` `(lheight + 1);` `        ``else` `            ``return` `(rheight + 1);` `    ``}` `}`   `/* Helper function that allocates a new node with the` `   ``given data and NULL left and right pointers. */` `struct` `node* newNode(``int` `data)` `{` `    ``struct` `node* node` `        ``= (``struct` `node*)``malloc``(``sizeof``(``struct` `node));` `    ``node->data = data;` `    ``node->left = NULL;` `    ``node->right = NULL;`   `    ``return` `(node);` `}`   `/* Driver program to test above functions*/` `int` `main()` `{` `    ``struct` `node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->left->left = newNode(4);` `    ``root->left->right = newNode(5);`   `    ``printf``(``"Level Order traversal of binary tree is \n"``);` `    ``printLevelOrder(root);`   `    ``return` `0;` `}`

## Java

 `// Recursive Java program for level` `// order traversal of Binary Tree`   `/* Class containing left and right child of current` `   ``node and key value*/` `class` `Node {` `    ``int` `data;` `    ``Node left, right;` `    ``public` `Node(``int` `item)` `    ``{` `        ``data = item;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `BinaryTree {` `    ``// Root of the Binary Tree` `    ``Node root;`   `    ``public` `BinaryTree() { root = ``null``; }`   `    ``/* function to print level order traversal of tree*/` `    ``void` `printLevelOrder()` `    ``{` `        ``int` `h = height(root);` `        ``int` `i;` `        ``for` `(i = ``1``; i <= h; i++)` `            ``printCurrentLevel(root, i);` `    ``}`   `    ``/* 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 root)` `    ``{` `        ``if` `(root == ``null``)` `            ``return` `0``;` `        ``else` `{` `            ``/* compute  height of each subtree */` `            ``int` `lheight = height(root.left);` `            ``int` `rheight = height(root.right);`   `            ``/* use the larger one */` `            ``if` `(lheight > rheight)` `                ``return` `(lheight + ``1``);` `            ``else` `                ``return` `(rheight + ``1``);` `        ``}` `    ``}`   `    ``/* Print nodes at the current level */` `    ``void` `printCurrentLevel(Node root, ``int` `level)` `    ``{` `        ``if` `(root == ``null``)` `            ``return``;` `        ``if` `(level == ``1``)` `            ``System.out.print(root.data + ``" "``);` `        ``else` `if` `(level > ``1``) {` `            ``printCurrentLevel(root.left, level - ``1``);` `            ``printCurrentLevel(root.right, level - ``1``);` `        ``}` `    ``}`   `    ``/* Driver program to test above functions */` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``BinaryTree tree = ``new` `BinaryTree();` `        ``tree.root = ``new` `Node(``1``);` `        ``tree.root.left = ``new` `Node(``2``);` `        ``tree.root.right = ``new` `Node(``3``);` `        ``tree.root.left.left = ``new` `Node(``4``);` `        ``tree.root.left.right = ``new` `Node(``5``);`   `        ``System.out.println(``"Level order traversal of"` `                           ``+ ``"binary tree is "``);` `        ``tree.printLevelOrder();` `    ``}` `}`

## Python3

 `# Recursive Python program for level` `# order traversal of Binary Tree`   `# A node structure`     `class` `Node:`   `    ``# A utility function to create a new node` `    ``def` `__init__(``self``, key):` `        ``self``.data ``=` `key` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`     `# Function to  print level order traversal of tree` `def` `printLevelOrder(root):` `    ``h ``=` `height(root)` `    ``for` `i ``in` `range``(``1``, h``+``1``):` `        ``printCurrentLevel(root, i)`     `# Print nodes at a current level` `def` `printCurrentLevel(root, level):` `    ``if` `root ``is` `None``:` `        ``return` `    ``if` `level ``=``=` `1``:` `        ``print``(root.data, end``=``" "``)` `    ``elif` `level > ``1``:` `        ``printCurrentLevel(root.left, level``-``1``)` `        ``printCurrentLevel(root.right, level``-``1``)`     `""" Compute the height of a tree--the number of nodes` `    ``along the longest path from the root node down to` `    ``the farthest leaf node` `"""`     `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` `        ``if` `lheight > rheight:` `            ``return` `lheight``+``1` `        ``else``:` `            ``return` `rheight``+``1`     `# Driver program to test above function` `root ``=` `Node(``1``)` `root.left ``=` `Node(``2``)` `root.right ``=` `Node(``3``)` `root.left.left ``=` `Node(``4``)` `root.left.right ``=` `Node(``5``)`   `print``(``"Level order traversal of binary tree is -"``)` `printLevelOrder(root)`   `# This code is contributed by Nikhil Kumar Singh(nickzuck_007)`

## C#

 `// Recursive c# program for level` `// order traversal of Binary Tree` `using` `System;`   `/* Class containing left and right` `   ``child of current node and key value*/` `public` `class` `Node {` `    ``public` `int` `data;` `    ``public` `Node left, right;` `    ``public` `Node(``int` `item)` `    ``{` `        ``data = item;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `GFG {` `    ``// Root of the Binary Tree` `    ``public` `Node root;`   `    ``public` `void` `BinaryTree() { root = ``null``; }`   `    ``/* function to print level order` `       ``traversal of tree*/` `    ``public` `virtual` `void` `printLevelOrder()` `    ``{` `        ``int` `h = height(root);` `        ``int` `i;` `        ``for` `(i = 1; i <= h; i++) {` `            ``printCurrentLevel(root, i);` `        ``}` `    ``}`   `    ``/* Compute the "height" of a tree --` `    ``the number of nodes along the longest` `    ``path from the root node down to the` `    ``farthest leaf node.*/` `    ``public` `virtual` `int` `height(Node root)` `    ``{` `        ``if` `(root == ``null``) {` `            ``return` `0;` `        ``}` `        ``else` `{` `            ``/* compute height of each subtree */` `            ``int` `lheight = height(root.left);` `            ``int` `rheight = height(root.right);`   `            ``/* use the larger one */` `            ``if` `(lheight > rheight) {` `                ``return` `(lheight + 1);` `            ``}` `            ``else` `{` `                ``return` `(rheight + 1);` `            ``}` `        ``}` `    ``}`   `    ``/* Print nodes at the current level */` `    ``public` `virtual` `void` `printCurrentLevel(Node root,` `                                          ``int` `level)` `    ``{` `        ``if` `(root == ``null``) {` `            ``return``;` `        ``}` `        ``if` `(level == 1) {` `            ``Console.Write(root.data + ``" "``);` `        ``}` `        ``else` `if` `(level > 1) {` `            ``printCurrentLevel(root.left, level - 1);` `            ``printCurrentLevel(root.right, level - 1);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``GFG tree = ``new` `GFG();` `        ``tree.root = ``new` `Node(1);` `        ``tree.root.left = ``new` `Node(2);` `        ``tree.root.right = ``new` `Node(3);` `        ``tree.root.left.left = ``new` `Node(4);` `        ``tree.root.left.right = ``new` `Node(5);`   `        ``Console.WriteLine(``"Level order traversal "` `                          ``+ ``"of binary tree is "``);` `        ``tree.printLevelOrder();` `    ``}` `}`   `// This code is contributed by Shrikant13`

## Javascript

 ``

Output

```Level Order traversal of binary tree is
1 2 3 4 5 ```

Time Complexity: O(N2), where N is the number of nodes in the skewed tree. So time complexity of printLevelOrder() is O(n) + O(n-1) + O(n-2) + .. + O(1) which is O(N2).
Auxiliary Space:  O(N) in the worst case. For a skewed tree, printGivenLevel() uses O(n) space for the call stack. For a Balanced tree, the call stack uses O(log n) space, (i.e., the height of the balanced tree).

## Level Order Binary Tree Traversal Using Queue

For each node, first, the node is visited and then it’s child nodes are put in a FIFO queue. Then again the first node is poped out and the it’s child nodes are put in a FIFO queue and repeat until que becomes empty.

Follow the below steps to Implement the above idea:

• Create an empty queue q and push root in q.
• Run While loop until q is not empty.
• Initialize temp_node = q.front() and print temp_node->data.
• Push temp_node’s children i.e. temp_node -> left then temp_node -> right to q
• Pop front node from q.

Below is the Implementation of the above approach:

## C++

 `/* C++ program to print level` `    ``order traversal using STL */` `#include ` `using` `namespace` `std;`   `// A Binary Tree Node` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node *left, *right;` `};`   `// Iterative method to find height of Binary Tree` `void` `printLevelOrder(Node* root)` `{` `    ``// Base Case` `    ``if` `(root == NULL)` `        ``return``;`   `    ``// Create an empty queue for level order traversal` `    ``queue q;`   `    ``// Enqueue Root and initialize height` `    ``q.push(root);`   `    ``while` `(q.empty() == ``false``) {` `        ``// Print front of queue and remove it from queue` `        ``Node* node = q.front();` `        ``cout << node->data << ``" "``;` `        ``q.pop();`   `        ``/* Enqueue left child */` `        ``if` `(node->left != NULL)` `            ``q.push(node->left);`   `        ``/*Enqueue right child */` `        ``if` `(node->right != NULL)` `            ``q.push(node->right);` `    ``}` `}`   `// Utility function to create a new tree node` `Node* newNode(``int` `data)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->data = data;` `    ``temp->left = temp->right = NULL;` `    ``return` `temp;` `}`   `// Driver program to test above functions` `int` `main()` `{` `    ``// Let us create binary tree shown in above diagram` `    ``Node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->left->left = newNode(4);` `    ``root->left->right = newNode(5);`   `    ``cout << ``"Level Order traversal of binary tree is \n"``;` `    ``printLevelOrder(root);` `    ``return` `0;` `}`

## C

 `// Iterative Queue based C program` `// to do level order traversal` `// of Binary Tree` `#include ` `#include ` `#define MAX_Q_SIZE 500`   `/* A binary tree node has data,` `   ``pointer to left child` `   ``and a pointer to right child */` `struct` `node {` `    ``int` `data;` `    ``struct` `node* left;` `    ``struct` `node* right;` `};`   `/* frunction prototypes */` `struct` `node** createQueue(``int``*, ``int``*);` `void` `enQueue(``struct` `node**, ``int``*, ``struct` `node*);` `struct` `node* deQueue(``struct` `node**, ``int``*);`   `/* Given a binary tree, print its nodes in level order` `   ``using array for implementing queue */` `void` `printLevelOrder(``struct` `node* root)` `{` `    ``int` `rear, front;` `    ``struct` `node** queue = createQueue(&front, &rear);` `    ``struct` `node* temp_node = root;`   `    ``while` `(temp_node) {` `        ``printf``(``"%d "``, temp_node->data);`   `        ``/*Enqueue left child */` `        ``if` `(temp_node->left)` `            ``enQueue(queue, &rear, temp_node->left);`   `        ``/*Enqueue right child */` `        ``if` `(temp_node->right)` `            ``enQueue(queue, &rear, temp_node->right);`   `        ``/*Dequeue node and make it temp_node*/` `        ``temp_node = deQueue(queue, &front);` `    ``}` `}`   `/*UTILITY FUNCTIONS*/` `struct` `node** createQueue(``int``* front, ``int``* rear)` `{` `    ``struct` `node** queue = (``struct` `node**)``malloc``(` `        ``sizeof``(``struct` `node*) * MAX_Q_SIZE);`   `    ``*front = *rear = 0;` `    ``return` `queue;` `}`   `void` `enQueue(``struct` `node** queue, ``int``* rear,` `             ``struct` `node* new_node)` `{` `    ``queue[*rear] = new_node;` `    ``(*rear)++;` `}`   `struct` `node* deQueue(``struct` `node** queue, ``int``* front)` `{` `    ``(*front)++;` `    ``return` `queue[*front - 1];` `}`   `/* Helper function that allocates a new node with the` `   ``given data and NULL left and right pointers. */` `struct` `node* newNode(``int` `data)` `{` `    ``struct` `node* node` `        ``= (``struct` `node*)``malloc``(``sizeof``(``struct` `node));` `    ``node->data = data;` `    ``node->left = NULL;` `    ``node->right = NULL;`   `    ``return` `(node);` `}`   `/* Driver program to test above functions*/` `int` `main()` `{` `    ``struct` `node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->left->left = newNode(4);` `    ``root->left->right = newNode(5);`   `    ``printf``(``"Level Order traversal of binary tree is \n"``);` `    ``printLevelOrder(root);`   `    ``return` `0;` `}`

## Java

 `// Iterative Queue based Java program` `// to do level order traversal` `// of Binary Tree`   `/* importing the inbuilt java classes` `   ``required for the program */` `import` `java.util.LinkedList;` `import` `java.util.Queue;`   `/* Class to represent Tree node */` `class` `Node {` `    ``int` `data;` `    ``Node left, right;`   `    ``public` `Node(``int` `item)` `    ``{` `        ``data = item;` `        ``left = ``null``;` `        ``right = ``null``;` `    ``}` `}`   `/* Class to print Level Order Traversal */` `class` `BinaryTree {`   `    ``Node root;`   `    ``/* Given a binary tree. Print` `     ``its nodes in level order` `     ``using array for implementing queue  */` `    ``void` `printLevelOrder()` `    ``{` `        ``Queue queue = ``new` `LinkedList();` `        ``queue.add(root);` `        ``while` `(!queue.isEmpty()) {`   `            ``/* poll() removes the present head.` `            ``For more information on poll() visit` `            ``http://www.tutorialspoint.com/java/` `            ``util/linkedlist_poll.htm */` `            ``Node tempNode = queue.poll();` `            ``System.out.print(tempNode.data + ``" "``);`   `            ``/*Enqueue left child */` `            ``if` `(tempNode.left != ``null``) {` `                ``queue.add(tempNode.left);` `            ``}`   `            ``/*Enqueue right child */` `            ``if` `(tempNode.right != ``null``) {` `                ``queue.add(tempNode.right);` `            ``}` `        ``}` `    ``}`   `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``/* creating a binary tree and entering` `         ``the nodes */` `        ``BinaryTree tree_level = ``new` `BinaryTree();` `        ``tree_level.root = ``new` `Node(``1``);` `        ``tree_level.root.left = ``new` `Node(``2``);` `        ``tree_level.root.right = ``new` `Node(``3``);` `        ``tree_level.root.left.left = ``new` `Node(``4``);` `        ``tree_level.root.left.right = ``new` `Node(``5``);`   `        ``System.out.println(``"Level order traversal of binary tree is - "``);` `        ``tree_level.printLevelOrder();` `    ``}` `}`

## Python3

 `# Python program to print level` `# order traversal using Queue`   `# A node structure`     `class` `Node:` `    ``# A utility function to create a new node` `    ``def` `__init__(``self``, key):` `        ``self``.data ``=` `key` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# Iterative Method to print the` `# height of a binary tree`     `def` `printLevelOrder(root):` `    ``# Base Case` `    ``if` `root ``is` `None``:` `        ``return`   `    ``# Create an empty queue` `    ``# for level order traversal` `    ``queue ``=` `[]`   `    ``# Enqueue Root and initialize height` `    ``queue.append(root)`   `    ``while``(``len``(queue) > ``0``):`   `        ``# Print front of queue and` `        ``# remove it from queue` `        ``print``(queue[``0``].data, end ``=` `" "``)` `        ``node ``=` `queue.pop(``0``)`   `        ``# Enqueue left child` `        ``if` `node.left ``is` `not` `None``:` `            ``queue.append(node.left)`   `        ``# Enqueue right child` `        ``if` `node.right ``is` `not` `None``:` `            ``queue.append(node.right)`     `# Driver Program to test above function` `root ``=` `Node(``1``)` `root.left ``=` `Node(``2``)` `root.right ``=` `Node(``3``)` `root.left.left ``=` `Node(``4``)` `root.left.right ``=` `Node(``5``)`   `print``(``"Level Order Traversal of binary tree is -"``)` `printLevelOrder(root)` `# This code is contributed by Nikhil Kumar Singh(nickzuck_007)`

## C#

 `// Iterative Queue based C# program` `// to do level order traversal` `// of Binary Tree`   `using` `System;` `using` `System.Collections.Generic;`   `/* Class to represent Tree node */` `public` `class` `Node {` `    ``public` `int` `data;` `    ``public` `Node left, right;`   `    ``public` `Node(``int` `item)` `    ``{` `        ``data = item;` `        ``left = ``null``;` `        ``right = ``null``;` `    ``}` `}`   `/* Class to print Level Order Traversal */` `public` `class` `BinaryTree {`   `    ``Node root;`   `    ``/* Given a binary tree. Print` `    ``its nodes in level order using` `     ``array for implementing queue */` `    ``void` `printLevelOrder()` `    ``{` `        ``Queue queue = ``new` `Queue();` `        ``queue.Enqueue(root);` `        ``while` `(queue.Count != 0) {`   `            ``Node tempNode = queue.Dequeue();` `            ``Console.Write(tempNode.data + ``" "``);`   `            ``/*Enqueue left child */` `            ``if` `(tempNode.left != ``null``) {` `                ``queue.Enqueue(tempNode.left);` `            ``}`   `            ``/*Enqueue right child */` `            ``if` `(tempNode.right != ``null``) {` `                ``queue.Enqueue(tempNode.right);` `            ``}` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``/* creating a binary tree and entering` `        ``the nodes */` `        ``BinaryTree tree_level = ``new` `BinaryTree();` `        ``tree_level.root = ``new` `Node(1);` `        ``tree_level.root.left = ``new` `Node(2);` `        ``tree_level.root.right = ``new` `Node(3);` `        ``tree_level.root.left.left = ``new` `Node(4);` `        ``tree_level.root.left.right = ``new` `Node(5);`   `        ``Console.WriteLine(``"Level order traversal "` `                          ``+ ``"of binary tree is - "``);` `        ``tree_level.printLevelOrder();` `    ``}` `}`   `/* This code contributed by PrinciRaj1992 */`

## Javascript

 ``

Output

```Level Order traversal of binary tree is
1 2 3 4 5 ```

Time Complexity: O(N) where n is the number of nodes in the binary tree.
Auxiliary Space: O(N) where n is the number of nodes in the binary tree.

Please write comments if you find any bugs in the above programs/algorithms or other ways to solve the same problem.

My Personal Notes arrow_drop_up
Recommended Articles
Page :