Given a Binary Tree, the task is to print the Bottom-left to Upward-right Traversal of the given Binary Tree i.e., the level order traversal having level as Bottom-left to Upward-right node.
Examples:
Input: Below is the given Tree:
Output: 2 7 2 5 6 5 11 4 9
Explanation:
Level 1: 2 7 2 (going upwards from bottom left to right to root)
Level 2: 5 6 5 (right from each node in layer 1/or bottom left to upwards right in this layer)
Level 3: 11 4 9 (right from each node in layer 2/or bottom left to upwards right in this layer)Input: 1 2 3 4 5 6 7
Output: 4 2 1 5 6 3 2Explanation
Layer 1: 4 2 1 (going upwards from bottom left to right to root)
Layer 2: 5 6 3 (right from each node in layer 1/or bottom left to upwards right in this layer)
Layer 3: 2 (right from each node in layer 2/or bottom left to upwards right in this layer)
Approach: The idea is to use the Breadth-First Search technique. Follow the steps needed to solve this problem:
- Initialize a layer in a binary tree. It is a list of nodes starting from the bottom-left most node next to the previous layer and ends with the upper-right most node next to the previous layer.
- Create a stack to stores all nodes in every layer.
- Initialize a queue to maintain “roots” in each layer, a root in a layer is a node from which one may go downwards using left children only.
- Push the root node of the first layer (the tree root) in the queue.
- Define an indicator (say lyr_root) a node expected at the end of a layer which is the current layer head, a layer head is the first node in a layer.
- Traverse until the queue is nonempty and do the following:
- Get a layer root from the front of the queue
- If this layer root is the layer head of a new layer, then, pop every element in the stack i.e., of the previous layer element, and print it.
- Traverse the layer from the upper-right to the bottom-left and for each element, if it has a right child, then check if the traversed node is the layer head or not. If found to be true then, change the expected indicator to indicate to the next layer head.
- Push the right child to the root in the queue.
- Push the traversed node in the stack.
- After traversing all the layers, the final layer may still be in the stack, so we need to pop every element from it and print it.
Below is the implementation of the above approach:
C++
// C++ program for the above approach#include <bits/stdc++.h>#include <iostream>using namespace std;
// Node Structurestypedef struct Node {
int data;
Node* left;
Node* right;
} Node;// Function to add the new Node in// the Binary TreeNode* newNode(int data)
{ Node* n;
// Create a new Node
n = new Node();
n->data = data;
n->right = NULL;
n->left = NULL;
return n;
}// Function to traverse the tree in the// order of bottom left to the upward// right ordervector<int>
leftBottomTopRightTraversal(Node* root){ // Stores the data of the node
vector<int> rr;
// Stores every element in each layer
stack<int> r;
// Stores the roots in the layers
queue<Node*> roots;
// Push the layer head of the
// first layer
roots.push(root);
// Define the first layer head
// as the tree root
Node* lyr_root = root;
// Traverse all layers
while (!roots.empty()) {
// get current layer root
Node* n = roots.front();
// Pop element from roots
roots.pop();
if (lyr_root == n) {
// Layer root was also
// the layer head
while (!r.empty()) {
rr.push_back(r.top());
// Pop every element
// from the stack
r.pop();
}
}
while (n) {
if (n->right) {
// Current traversed node
// has right child then
// this root is next layer
if (n == lyr_root) {
lyr_root = n->right;
}
// Push the right child
// to layer roots queue
roots.push(n->right);
}
// Push node to the
// layer stack
r.push(n->data);
n = n->left;
}
}
// Insert all remaining elements
// for the traversal
while (!r.empty()) {
// After all of the layer
// roots traversed check the
// final layer in stack
rr.push_back(r.top());
r.pop();
}
// Return the traversal of nodes
return rr;
}// Function that builds the binary tree// from the given stringNode* buildBinaryTree(char* t)
{ Node* root = NULL;
// Using queue to build tree
queue<Node**> q;
int data = 0;
// Stores the status of last
// node to be ignored or not
bool ignore_last = false;
while (*t != '\0') {
int d = *t - '0';
// If the current character
// is a digits then form the
// number of it
if (d >= 0 && d <= 9) {
data *= 10;
data += d;
ignore_last = false;
}
// If the current character
// is N then it is the
// NULL node
else if (*t == 'N') {
data = 0;
q.pop();
ignore_last = true;
}
// If space occurred then
// add the number formed
else if (*t == ' ') {
// If last is ignored
if (!ignore_last) {
// If root node is not NULL
if (root) {
Node** p = q.front();
q.pop();
if (p != NULL) {
*p = newNode(data);
q.push(&((*p)->left));
q.push(&((*p)->right));
}
}
// Else create a new
// root node
else {
root = newNode(data);
q.push(&(root->left));
q.push(&(root->right));
}
data = 0;
}
}
// Increment t
t++;
}
// Return the root node of the tree
return root;
}// Driver Codeint main()
{ // Given order of nodes
char T[] = "2 7 5 2 6 N 9 N N 5 11 4 N";
// Builds the Binary Tree
Node* root = buildBinaryTree(T);
// Function Call
vector<int> result
= leftBottomTopRightTraversal(root);
// Print the final traversal
for (int i = 0; i < result.size(); ++i) {
cout << result[i] << " ";
}
return 0;
} |
Java
// Java program for the above approachimport java.util.*;
// Node Classclass Node {
int data;
Node left, right;
Node(int data) {
this.data = data;
left = right = null;
}
}class Main {
// Function to add the new Node in
// the Binary Tree
static Node newNode(int data) {
// Create a new Node
Node n = new Node(data);
n.right = null;
n.left = null;
return n;
}
// Function to traverse the tree in the
// order of bottom left to the upward
// right order
static List<Integer> leftBottomTopRightTraversal(Node root) {
// Stores the data of the node
List<Integer> rr = new ArrayList<>();
// Stores every element in each layer
Stack<Integer> r = new Stack<>();
// Stores the roots in the layers
Queue<Node> roots = new LinkedList<>();
// Push the layer head of the
// first layer
roots.add(root);
// Define the first layer head
// as the tree root
Node lyr_root = root;
// Traverse all layers
while (!roots.isEmpty()) {
// get current layer root and will remove
// the element from the root
Node n = roots.poll();
if (lyr_root == n) {
// Layer root was also
// the layer head
while (!r.empty()) {
rr.add(r.peek());
// Pop every element
// from the stack
r.pop();
}
}
while (n != null) {
if (n.right != null) {
// Current traversed node
// has right child then
// this root is next layer
if (n == lyr_root) {
lyr_root = n.right;
}
// Push the right child
// to layer roots queue
roots.add(n.right);
}
// Push node to the
// layer stack
r.push(n.data);
n = n.left;
}
}
// Insert all remaining elements
// for the traversal
while (!r.empty()) {
// After all of the layer
// roots traversed check the
// final layer in stack
rr.add(r.peek());
r.pop();
}
// Return the traversal of nodes
return rr;
}
// Function that builds the binary tree
// from the given string
public static Node buildBinaryTree(String input) {
if (input == null || input.isEmpty()) {
return null;
}
String[] values = input.trim().split("\\s+");
if (values.length == 0) {
return null;
}
Node root = new Node(Integer.parseInt(values[0]));
Queue<Node> queue = new LinkedList<>();
queue.offer(root);
for (int i = 1; i < values.length; i += 2) {
Node parent = queue.poll();
if (!values[i].equals("N")) {
Node left = new Node(Integer.parseInt(values[i]));
parent.left = left;
queue.offer(left);
}
if (i + 1 < values.length && !values[i+1].equals("N")) {
Node right = new Node(Integer.parseInt(values[i+1]));
parent.right = right;
queue.offer(right);
}
}
return root;
}
// Driver Code
public static void main(String[] args) {
// Given order of nodes
String T = "2 7 5 2 6 N 9 N N 5 11 4 N";
// Builds the Binary Tree
Node root = buildBinaryTree(T);
// Function Call
List<Integer> result = leftBottomTopRightTraversal(root);
// Print the Final Traversal
for (int i = 0; i < result.size(); i++) {
System.out.print(result.get(i) + " ");
}
}
}// This code is contributed by rishabmalhdijo |
Python3
# Python program for the above approach# Node Classclass Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
# Function to add the new Node in# the Binary Treedef newNode(data):
# Create a new Node
n = Node(data)
n.right = None
n.left = None
return n
# Function to traverse the tree in the# order of bottom left to the upward# right orderdef leftBottomTopRightTraversal(root):
# Stores the data of the node
rr = []
# Stores every element in each layer
r = []
# Stores the roots in the layers
roots = []
# Push the layer head of the
# first layer
roots.append(root)
# Define the first layer head
# as the tree root
lyr_root = root
# Traverse all layers
while roots:
# get current layer root and will remove
# the element from the root
n = roots.pop(0)
if lyr_root == n:
# Layer root was also
# the layer head
while r:
rr.append(r[-1])
# Pop every element
# from the stack
r.pop()
while n:
if n.right:
# Current traversed node
# has right child then
# this root is next layer
if n == lyr_root:
lyr_root = n.right
# Push the right child
# to layer roots queue
roots.append(n.right)
# Push node to the
# layer stack
r.append(n.data)
n = n.left
# Insert all remaining elements
# for the traversal
while r:
# After all of the layer
# roots traversed check the
# final layer in stack
rr.append(r[-1])
r.pop()
# Return the traversal of nodes
return rr
# Function that builds the binary tree# from the given stringdef buildBinaryTree(input):
if input is None or input == '':
return None
values = input.strip().split()
if not values:
return None
root = Node(int(values[0]))
queue = []
queue.append(root)
for i in range(1, len(values), 2):
parent = queue.pop(0)
if values[i] != 'N':
left = Node(int(values[i]))
parent.left = left
queue.append(left)
if i + 1 < len(values) and values[i+1] != 'N':
right = Node(int(values[i+1]))
parent.right = right
queue.append(right)
return root
# Driver Codeif __name__ == '__main__':
# Given order of nodes
T = "2 7 5 2 6 N 9 N N 5 11 4 N"
# Builds the Binary Tree
root = buildBinaryTree(T)
# Function Call
result = leftBottomTopRightTraversal(root)
# Print the Final Traversal
for i in range(len(result)):
print(result[i], end=' ')
# This code is contributed by Prince Kumar |
C#
// C# code implementation using System;
using System.Collections.Generic;
// Node Classpublic class Node {
public int data;
public Node left, right;
public Node(int data) {
this.data = data;
left = right = null;
}
}class MainClass {
// Function to add the new Node in
// the Binary Tree
static Node newNode(int data) {
// Create a new Node
Node n = new Node(data);
n.right = null;
n.left = null;
return n;
}
// Function to traverse the tree in the
// order of bottom left to the upward
// right order
static List<int> leftBottomTopRightTraversal(Node root) {
// Stores the data of the node
List<int> rr = new List<int>();
// Stores every element in each layer
Stack<int> r = new Stack<int>();
// Stores the roots in the layers
Queue<Node> roots = new Queue<Node>();
// Push the layer head of the
// first layer
roots.Enqueue(root);
// Define the first layer head
// as the tree root
Node lyr_root = root;
// Traverse all layers
while (roots.Count > 0) {
// get current layer root and will remove
// the element from the root
Node n = roots.Dequeue();
if (lyr_root == n) {
// Layer root was also
// the layer head
while (r.Count > 0) {
rr.Add(r.Peek());
// Pop every element
// from the stack
r.Pop();
}
}
while (n != null) {
if (n.right != null) {
// Current traversed node
// has right child then
// this root is next layer
if (n == lyr_root) {
lyr_root = n.right;
}
// Push the right child
// to layer roots queue
roots.Enqueue(n.right);
}
// Push node to the
// layer stack
r.Push(n.data);
n = n.left;
}
}
// Insert all remaining elements
// for the traversal
while (r.Count > 0) {
// After all of the layer
// roots traversed check the
// final layer in stack
rr.Add(r.Peek());
r.Pop();
}
// Return the traversal of nodes
return rr;
}
// Function that builds the binary tree
// from the given string
public static Node buildBinaryTree(string input) {
if (input == null || input.Length == 0) {
return null;
}
string[] values = input.Trim().Split(' ');
if (values.Length == 0) {
return null;
}
Node root = new Node(int.Parse(values[0]));
Queue<Node> queue = new Queue<Node>();
queue.Enqueue(root);
for (int i = 1; i < values.Length; i += 2) {
Node parent = queue.Dequeue();
if (!values[i].Equals("N")) {
Node left = new Node(int.Parse(values[i]));
parent.left = left;
queue.Enqueue(left);
}
if (i + 1 < values.Length && !values[i+1].Equals("N")) {
Node right = new Node(int.Parse(values[i+1]));
parent.right = right;
queue.Enqueue(right);
}
}
return root;
}
// Driver Code
static void Main() {
// Given order of nodes
string T = "2 7 5 2 6 N 9 N N 5 11 4 N";
// Builds the Binary Tree
Node root = buildBinaryTree(T);
// Function Call
List<int> result = leftBottomTopRightTraversal(root);
// Print the Final Traversal
for (int i = 0; i < result.Count; i++) {
Console.Write(result[i] + " ");
}
}
}// The code is contributed by Nidhi goel. |
Javascript
// Node Classclass Node { constructor(data) {
this.data = data;
this.left = null;
this.right = null;
}
}// Function to add the new Node in// the Binary Treefunction newNode(data) {
// Create a new Node
let n = new Node(data);
n.right = null;
n.left = null;
return n;
}// Function to traverse the tree in the// order of bottom left to the upward// right orderfunction leftBottomTopRightTraversal(root) {
// Stores the data of the node
let rr = [];
// Stores every element in each layer
let r = [];
// Stores the roots in the layers
let roots = [];
// Push the layer head of the
// first layer
roots.push(root);
// Define the first layer head
// as the tree root
let lyr_root = root;
// Traverse all layers
while (roots.length > 0) {
// get current layer root and will remove
// the element from the root
let n = roots.shift();
if (lyr_root == n) {
// Layer root was also
// the layer head
while (r.length > 0) {
rr.push(r[r.length - 1]);
// Pop every element
// from the stack
r.pop();
}
}
while (n != null) {
if (n.right != null) {
// Current traversed node
// has right child then
// this root is next layer
if (n == lyr_root) {
lyr_root = n.right;
}
// Push the right child
// to layer roots queue
roots.push(n.right);
}
// Push node to the
// layer stack
r.push(n.data);
n = n.left;
}
}
// Insert all remaining elements
// for the traversal
while (r.length > 0) {
// After all of the layer
// roots traversed check the
// final layer in stack
rr.push(r[r.length - 1]);
r.pop();
}
// Return the traversal of nodes
return rr;
}// Function that builds the binary tree// from the given stringfunction buildBinaryTree(input) {
if (input == null || input == "") {
return null;
}
let values = input.trim().split(" ");
if (values.length == 0) {
return null;
}
let root = new Node(parseInt(values[0]));
let queue = [];
queue.push(root);
for (let i = 1; i < values.length; i += 2) {
let parent = queue.shift();
if (values[i] != "N") {
let left = new Node(parseInt(values[i]));
parent.left = left;
queue.push(left);
}
if (i + 1 < values.length && values[i + 1] != "N") {
let right = new Node(parseInt(values[i + 1]));
parent.right = right;
queue.push(right);
}
}
return root;
}// Driver Codelet T = "2 7 5 2 6 N 9 N N 5 11 4 N";
// Builds the Binary Treelet root = buildBinaryTree(T);// Function Calllet result = leftBottomTopRightTraversal(root);// Print the Final Traversalconsole.log(result.join(" "))
|
Output:
2 7 2 5 6 5 11 4 9
Time Complexity: O(N)
Auxiliary Space: O(N)