Reverse Level Order Traversal
We have discussed the level-order traversal of a tree in the previous post. 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.
The reverse Level order traversal of the above tree is “4 5 2 3 1”.
Both methods for normal level order traversal can be easily modified to do reverse level order traversal.
METHOD 1 (Recursive function to print a given level)
We can easily modify method 1 of the normal level order traversal. In method 1, we have a method printGivenLevel() which prints a given level number. The only thing we need to change is, instead of calling printGivenLevel() from the first level to the last level, we call it from the last level to the first level.
C++
#include <bits/stdc++.h>
using namespace std;
class node
{
public :
int data;
node* left;
node* right;
};
void printGivenLevel(node* root, int level);
int height(node* node);
node* newNode( int data);
void reverseLevelOrder(node* root)
{
int h = height(root);
int i;
for (i=h; i>=1; i--)
printGivenLevel(root, i);
}
void printGivenLevel(node* root, int level)
{
if (root == NULL)
return ;
if (level == 1)
cout << root->data << " " ;
else if (level > 1)
{
printGivenLevel(root->left, level - 1);
printGivenLevel(root->right, level - 1);
}
}
int height(node* node)
{
if (node == NULL)
return 0;
else
{
int lheight = height(node->left);
int rheight = height(node->right);
if (lheight > rheight)
return (lheight + 1);
else return (rheight + 1);
}
}
node* newNode( int data)
{
node* Node = new node();
Node->data = data;
Node->left = NULL;
Node->right = NULL;
return (Node);
}
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" ;
reverseLevelOrder(root);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node* left;
struct node* right;
};
void printGivenLevel( struct node* root, int level);
int height( struct node* node);
struct node* newNode( int data);
void reverseLevelOrder( struct node* root)
{
int h = height(root);
int i;
for (i=h; i>=1; i--)
printGivenLevel(root, i);
}
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);
}
}
int height( struct node* node)
{
if (node==NULL)
return 0;
else
{
int lheight = height(node->left);
int rheight = height(node->right);
if (lheight > rheight)
return (lheight+1);
else return (rheight+1);
}
}
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);
}
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" );
reverseLevelOrder(root);
return 0;
}
|
Java
class Node
{
int data;
Node left, right;
Node( int item)
{
data = item;
left = right;
}
}
class BinaryTree
{
Node root;
void reverseLevelOrder(Node node)
{
int h = height(node);
int i;
for (i = h; i >= 1 ; i--)
{
printGivenLevel(node, i);
}
}
void printGivenLevel(Node node, int level)
{
if (node == null )
return ;
if (level == 1 )
System.out.print(node.data + " " );
else if (level > 1 )
{
printGivenLevel(node.left, level - 1 );
printGivenLevel(node.right, level - 1 );
}
}
int height(Node node)
{
if (node == null )
return 0 ;
else
{
int lheight = height(node.left);
int rheight = height(node.right);
if (lheight > rheight)
return (lheight + 1 );
else
return (rheight + 1 );
}
}
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.reverseLevelOrder(tree.root);
}
}
|
Python
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def reverseLevelOrder(root):
h = height(root)
for i in reversed ( range ( 1 , h + 1 )):
printGivenLevel(root,i)
def printGivenLevel(root, level):
if root is None :
return
if level = = 1 :
print root.data,
elif level> 1 :
printGivenLevel(root.left, level - 1 )
printGivenLevel(root.right, level - 1 )
def height(node):
if node is None :
return 0
else :
lheight = height(node.left)
rheight = height(node.right)
if lheight > rheight :
return lheight + 1
else :
return rheight + 1
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"
reverseLevelOrder(root)
|
C#
using System;
class Node
{
public int data;
public Node left, right;
public Node( int item)
{
data = item;
left = right;
}
}
class BinaryTree
{
Node root;
void reverseLevelOrder(Node node)
{
int h = height(node);
int i;
for (i = h; i >= 1; i--)
{
printGivenLevel(node, i);
}
}
void printGivenLevel(Node node, int level)
{
if (node == null )
return ;
if (level == 1)
Console.Write(node.data + " " );
else if (level > 1)
{
printGivenLevel(node.left, level - 1);
printGivenLevel(node.right, level - 1);
}
}
int height(Node node)
{
if (node == null )
return 0;
else
{
int lheight = height(node.left);
int rheight = height(node.right);
if (lheight > rheight)
return (lheight + 1);
else
return (rheight + 1);
}
}
static public 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);
Console.WriteLine( "Level Order traversal " +
"of binary tree is : " );
tree.reverseLevelOrder(tree.root);
}
}
|
Javascript
<script>
class Node {
constructor(item) {
this .data = item;
this .left = null ;
this .right = null ;
}
}
class BinaryTree {
constructor() {
this .root = null ;
}
reverseLevelOrder(node) {
var h = this .height(node);
var i;
for (
i = h;
i >= 1;
i--
) {
this .printGivenLevel(node, i);
}
}
printGivenLevel(node, level) {
if (node == null ) return ;
if (level == 1) document.write(node.data + " " );
else if (level > 1) {
this .printGivenLevel(node.left, level - 1);
this .printGivenLevel(node.right, level - 1);
}
}
height(node) {
if (node == null ) return 0;
else {
var lheight = this .height(node.left);
var rheight = this .height(node.right);
if (lheight > rheight) return lheight + 1;
else return rheight + 1;
}
}
}
var 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);
document.write(
"Level Order traversal " + "of binary tree is : <br>"
);
tree.reverseLevelOrder(tree.root);
</script>
|
Output
Level Order traversal of binary tree is
4 5 2 3 1
Time Complexity: O(n^2)
Auxiliary Space: O(h), where h is the height of the tree, this space is due to the recursive call stack.
METHOD 2 (Using Queue and Stack)
The idea is to use a deque(double-ended queue) to get the reverse level order. A deque allows insertion and deletion at both ends. If we do normal level order traversal and instead of printing a node, push the node to a stack and then print the contents of the deque, we get “5 4 3 2 1” for the above example tree, but the output should be “4 5 2 3 1”. So to get the correct sequence (left to right at every level), we process the children of a node in reverse order, we first push the right subtree to the deque, then process the left subtree.
C++
#include <bits/stdc++.h>
using namespace std;
struct node
{
int data;
struct node* left;
struct node* right;
};
void reverseLevelOrder(node* root)
{
stack <node *> S;
queue <node *> Q;
Q.push(root);
while (Q.empty() == false )
{
root = Q.front();
Q.pop();
S.push(root);
if (root->right)
Q.push(root->right);
if (root->left)
Q.push(root->left);
}
while (S.empty() == false )
{
root = S.top();
cout << root->data << " " ;
S.pop();
}
}
node* newNode( int data)
{
node* temp = new node;
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return (temp);
}
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);
root->right->left = newNode(6);
root->right->right = newNode(7);
cout << "Level Order traversal of binary tree is \n" ;
reverseLevelOrder(root);
return 0;
}
|
Java
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
class Node
{
int data;
Node left, right;
Node( int item)
{
data = item;
left = right;
}
}
class BinaryTree
{
Node root;
void reverseLevelOrder(Node node)
{
Stack<Node> S = new Stack();
Queue<Node> Q = new LinkedList();
Q.add(node);
while (Q.isEmpty() == false )
{
node = Q.peek();
Q.remove();
S.push(node);
if (node.right != null )
Q.add(node.right);
if (node.left != null )
Q.add(node.left);
}
while (S.empty() == false )
{
node = S.peek();
System.out.print(node.data + " " );
S.pop();
}
}
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 );
tree.root.right.left = new Node( 6 );
tree.root.right.right = new Node( 7 );
System.out.println( "Level Order traversal of binary tree is :" );
tree.reverseLevelOrder(tree.root);
}
}
|
Python
from collections import deque
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def reverseLevelOrder(root):
q = deque()
q.append(root)
ans = deque()
while q:
node = q.popleft()
if node is None :
continue
ans.appendleft(node.data)
if node.right:
q.append(node.right)
if node.left:
q.append(node.left)
return ans
root = Node( 1 )
root.left = Node( 2 )
root.right = Node( 3 )
root.left.left = Node( 4 )
root.left.right = Node( 5 )
root.right.left = Node( 6 )
root.right.right = Node( 7 )
print "Level Order traversal of binary tree is"
deq = reverseLevelOrder(root)
for key in deq:
print (key),
|
C#
using System.Collections.Generic;
using System;
public class Node
{
public int data;
public Node left, right;
public Node( int item)
{
data = item;
left = right;
}
}
public class BinaryTree
{
Node root;
void reverseLevelOrder(Node node)
{
Stack<Node> S = new Stack<Node>();
Queue<Node> Q = new Queue<Node>();
Q.Enqueue(node);
while (Q.Count>0)
{
node = Q.Peek();
Q.Dequeue();
S.Push(node);
if (node.right != null )
Q.Enqueue(node.right);
if (node.left != null )
Q.Enqueue(node.left);
}
while (S.Count>0)
{
node = S.Peek();
Console.Write(node.data + " " );
S.Pop();
}
}
public static void Main()
{
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);
tree.root.right.left = new Node(6);
tree.root.right.right = new Node(7);
Console.WriteLine( "Level Order traversal of binary tree is :" );
tree.reverseLevelOrder(tree.root);
}
}
|
Javascript
<script>
class Node
{
constructor(item)
{
this .data = item;
this .left = this .right= null ;
}
}
let root;
function reverseLevelOrder(node)
{
let S = [];
let Q = [];
Q.push(node);
while (Q.length != 0)
{
node = Q[0];
Q.shift();
S.push(node);
if (node.right != null )
Q.push(node.right);
if (node.left != null )
Q.push(node.left);
}
while (S.length != 0)
{
node = S.pop();
document.write(node.data + " " );
}
}
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.left = new Node(6);
root.right.right = new Node(7);
document.write( "Level Order traversal of binary tree is :<br>" );
reverseLevelOrder(root);
</script>
|
Output
Level Order traversal of binary tree is
4 5 6 7 2 3 1
Time Complexity: O(n), where n is the number of nodes in the binary tree.
Auxiliary Space: O(n), for stack and queue.
Method 3: ( Using a Hash_Map)
The basic idea behind this approach is to use a hashmap to store the nodes at each level of the binary tree, and then iterate over the hashmap in reverse order of the levels to obtain the reverse level order traversal.
Follow the steps to implement above idea:
- Define a Node struct to represent a binary tree node.
- Define a recursive function addNodesToMap that takes a binary tree node, a level, and a reference to an unordered map, and adds the node to the vector of nodes at its level in the unordered map. This function should then recursively call itself on the left and right subtrees.
- Define the main reverseLevelOrder function that takes the root of the binary tree as input, and returns a vector containing the nodes in reverse level order.
- Inside the reverseLevelOrder function, create an unordered map to store the nodes at each level of the binary tree.
- Call the addNodesToMap function on the root of the binary tree, with level 0 and a reference to the unordered map, to populate the map with nodes.
- Iterate over the unordered map in reverse order of the levels, and add the nodes to the result vector in the order they appear in the vectors in the unordered map.
- Return the result vector containing the nodes in reverse level order.
Below is the implementation:
C++
#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
struct Node {
int data;
Node* left;
Node* right;
Node( int val)
{
data = val;
left = right = nullptr;
}
};
void addNodesToMap(
Node* node, int level,
unordered_map< int , vector< int > >& nodeMap)
{
if (node == nullptr) {
return ;
}
nodeMap[level].push_back(node->data);
addNodesToMap(node->left, level + 1, nodeMap);
addNodesToMap(node->right, level + 1, nodeMap);
}
vector< int > reverseLevelOrder(Node* root)
{
vector< int > result;
unordered_map< int , vector< int > > nodeMap;
addNodesToMap(root, 0, nodeMap);
for ( int level = nodeMap.size() - 1; level >= 0;
level--) {
vector< int > nodesAtLevel = nodeMap[level];
for ( int i = 0; i < nodesAtLevel.size(); i++) {
result.push_back(nodesAtLevel[i]);
}
}
return result;
}
int main()
{
Node* root = new Node(10);
root->left = new Node(20);
root->right = new Node(30);
root->left->left = new Node(40);
root->left->right = new Node(60);
vector< int > result = reverseLevelOrder(root);
cout << "Level Order traversal of binary tree is:"
<< endl;
for ( int i = 0; i < result.size(); i++) {
cout << result[i] << " " ;
}
cout << endl;
return 0;
}
|
Java
import java.util.*;
class Node {
int data;
Node left;
Node right;
Node( int val) {
data = val;
left = right = null ;
}
}
class Main {
static void addNodesToMap(Node node, int level, Map<Integer, List<Integer>> nodeMap) {
if (node == null ) {
return ;
}
if (!nodeMap.containsKey(level)) {
nodeMap.put(level, new ArrayList<>());
}
nodeMap.get(level).add(node.data);
addNodesToMap(node.left, level + 1 , nodeMap);
addNodesToMap(node.right, level + 1 , nodeMap);
}
static List<Integer> reverseLevelOrder(Node root) {
List<Integer> result = new ArrayList<>();
Map<Integer, List<Integer>> nodeMap = new HashMap<>();
addNodesToMap(root, 0 , nodeMap);
for ( int level = nodeMap.size() - 1 ; level >= 0 ; level--) {
List<Integer> nodesAtLevel = nodeMap.get(level);
for ( int i = 0 ; i < nodesAtLevel.size(); i++) {
result.add(nodesAtLevel.get(i));
}
}
return result;
}
public static void main(String[] args) {
Node root = new Node( 10 );
root.left = new Node( 20 );
root.right = new Node( 30 );
root.left.left = new Node( 40 );
root.left.right = new Node( 60 );
List<Integer> result = reverseLevelOrder(root);
System.out.println( "Level Order traversal of binary tree is:" );
for ( int i = 0 ; i < result.size(); i++) {
System.out.print(result.get(i) + " " );
}
System.out.println();
}
}
|
Python
class Node:
def __init__( self , val):
self .data = val
self .left = None
self .right = None
def addNodesToMap(node, level, nodeMap):
if node is None :
return
if level in nodeMap:
nodeMap[level].append(node.data)
else :
nodeMap[level] = [node.data]
addNodesToMap(node.left, level + 1 , nodeMap)
addNodesToMap(node.right, level + 1 , nodeMap)
def GFG(root):
result = []
nodeMap = {}
addNodesToMap(root, 0 , nodeMap)
for level in range ( len (nodeMap) - 1 , - 1 , - 1 ):
nodesAtLevel = nodeMap[level]
result.extend(nodesAtLevel)
return result
if __name__ = = "__main__" :
root = Node( 10 )
root.left = Node( 20 )
root.right = Node( 30 )
root.left.left = Node( 40 )
root.left.right = Node( 60 )
result = GFG(root)
print ( "Level Order traversal of binary tree is:" )
print ( " " .join( map ( str , result)))
|
C#
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left;
public Node right;
public Node( int val)
{
data = val;
left = right = null ;
}
}
class Program {
static void
AddNodesToMap(Node node, int level,
Dictionary< int , List< int > > nodeMap)
{
if (node == null ) {
return ;
}
if (!nodeMap.ContainsKey(level)) {
nodeMap[level] = new List< int >();
}
nodeMap[level].Add(node.data);
AddNodesToMap(node.left, level + 1, nodeMap);
AddNodesToMap(node.right, level + 1, nodeMap);
}
static List< int > ReverseLevelOrder(Node root)
{
List< int > result = new List< int >();
Dictionary< int , List< int > > nodeMap
= new Dictionary< int , List< int > >();
AddNodesToMap(root, 0, nodeMap);
for ( int level = nodeMap.Count - 1; level >= 0;
level--) {
List< int > nodesAtLevel = nodeMap[level];
for ( int i = 0; i < nodesAtLevel.Count; i++) {
result.Add(nodesAtLevel[i]);
}
}
return result;
}
static void Main()
{
Node root = new Node(10);
root.left = new Node(20);
root.right = new Node(30);
root.left.left = new Node(40);
root.left.right = new Node(60);
List< int > result = ReverseLevelOrder(root);
Console.WriteLine(
"Level Order traversal of binary tree is:" );
foreach ( int val in result)
{
Console.Write(val + " " );
}
Console.WriteLine();
}
}
|
Javascript
class Node {
constructor(val) {
this .data = val;
this .left = null ;
this .right = null ;
}
}
function addNodesToMap(node, level, nodeMap) {
if (node === null ) {
return ;
}
if (!nodeMap[level]) {
nodeMap[level] = [];
}
nodeMap[level].push(node.data);
addNodesToMap(node.left, level + 1, nodeMap);
addNodesToMap(node.right, level + 1, nodeMap);
}
function reverseLevelOrder(root) {
const result = [];
const nodeMap = {};
addNodesToMap(root, 0, nodeMap);
const levels = Object.keys(nodeMap).map(Number);
levels.sort((a, b) => b - a);
for (const level of levels) {
result.push(...nodeMap[level]);
}
return result;
}
const root = new Node(10);
root.left = new Node(20);
root.right = new Node(30);
root.left.left = new Node(40);
root.left.right = new Node(60);
const result = reverseLevelOrder(root);
console.log( "Level Order traversal of binary tree is:" );
console.log(result.join( " " ));
|
Output
Level Order traversal of binary tree is:
40 60 20 30 10
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.
Last Updated :
04 Oct, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...