# Level Order Binary Tree Traversal

• Difficulty Level : Easy
• Last Updated : 26 Dec, 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 popped out and then it’s child nodes are put in a FIFO queue and repeat until queue 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