Perfect Binary Tree Specific Level Order Traversal | Set 2
Last Updated :
29 Dec, 2022
Perfect Binary Tree using Specific Level Order Traversal in Set 1. The earlier traversal was from Top to Bottom. In this post, Bottom to Top traversal (asked in Amazon Interview | Set 120 – Round 1) is discussed.
16 31 17 30 18 29 19 28 20 27 21 26 22 25 23 24 8 15 9 14 10 13 11 12 4 7 5 6 2 3 1
The task is to print nodes in level order but nodes should be from left and right side alternatively and from bottom – up manner
5th level: 16(left), 31(right), 17(left), 30(right), … are printed.
4th level: 8(left), 15(right), 9(left), 14(right), … are printed.
v
3rd level: 4(left), 7(right), 5(left), 6(right) are printed.
1st and 2nd levels are trivial.
Approach 1:
The standard level order traversal idea slightly changes here.
- Instead of processing ONE node at a time, we will process TWO nodes at a time.
- For dequeued nodes, we push node’s left and right child into stack in following manner - 2nd node’s left child, 1st node’s right child, 2nd node’s right child and 1st node’s left child.
- And while pushing children into queue, the enqueue order will be: 1st node’s right child, 2nd node’s left child, 1st node’s left child and 2nd node’s right child. Also, when we process two queue nodes.
- Finally pop all Nodes from stack and prints them.
Implementation:
C++
/* C++ program for special order traversal */
#include <bits/stdc++.h>
using namespace std;
/* A binary tree node has data, pointer to left child
and a pointer to right child */
struct Node
{
int data;
Node *left, *right;
};
/* 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->right = node->left = NULL;
return node;
}
void printSpecificLevelOrderUtil(Node* root, stack<Node*> &s)
{
if (root == NULL)
return;
// Create a queue and enqueue left and right
// children of root
queue<Node*> q;
q.push(root->left);
q.push(root->right);
// We process two nodes at a time, so we
// need two variables to store two front
// items of queue
Node *first = NULL, *second = NULL;
// traversal loop
while (!q.empty())
{
// Pop two items from queue
first = q.front();
q.pop();
second = q.front();
q.pop();
// Push first and second node's children
// in reverse order
s.push(second->left);
s.push(first->right);
s.push(second->right);
s.push(first->left);
// If first and second have grandchildren,
// enqueue them in specific order
if (first->left->left != NULL)
{
q.push(first->right);
q.push(second->left);
q.push(first->left);
q.push(second->right);
}
}
}
/* Given a perfect binary tree, print its nodes in
specific level order */
void printSpecificLevelOrder(Node* root)
{
//create a stack and push root
stack<Node*> s;
//Push level 1 and level 2 nodes in stack
s.push(root);
// Since it is perfect Binary Tree, right is
// not checked
if (root->left != NULL)
{
s.push(root->right);
s.push(root->left);
}
// Do anything more if there are nodes at next
// level in given perfect Binary Tree
if (root->left->left != NULL)
printSpecificLevelOrderUtil(root, s);
// Finally pop all Nodes from stack and prints
// them.
while (!s.empty())
{
cout << s.top()->data << " ";
s.pop();
}
}
/* Driver program to test above functions*/
int main()
{
// Perfect Binary Tree of Height 4
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);
root->left->left->left = newNode(8);
root->left->left->right = newNode(9);
root->left->right->left = newNode(10);
root->left->right->right = newNode(11);
root->right->left->left = newNode(12);
root->right->left->right = newNode(13);
root->right->right->left = newNode(14);
root->right->right->right = newNode(15);
root->left->left->left->left = newNode(16);
root->left->left->left->right = newNode(17);
root->left->left->right->left = newNode(18);
root->left->left->right->right = newNode(19);
root->left->right->left->left = newNode(20);
root->left->right->left->right = newNode(21);
root->left->right->right->left = newNode(22);
root->left->right->right->right = newNode(23);
root->right->left->left->left = newNode(24);
root->right->left->left->right = newNode(25);
root->right->left->right->left = newNode(26);
root->right->left->right->right = newNode(27);
root->right->right->left->left = newNode(28);
root->right->right->left->right = newNode(29);
root->right->right->right->left = newNode(30);
root->right->right->right->right = newNode(31);
*/
cout << "Specific Level Order traversal of binary "
"tree is \n";
printSpecificLevelOrder(root);
return 0;
}
// Java program for special order traversal
import java.util.*;
/* A binary tree node has data, pointer to left child
and a pointer to right child */
class Node
{
int data;
Node left, right;
public Node(int data)
{
this.data = data;
left = right = null;
}
}
class BinaryTree
{
Node root;
void printSpecificLevelOrderUtil(Node root, Stack<Node> s)
{
if (root == null)
return;
// Create a queue and enqueue left and right
// children of root
Queue<Node> q = new LinkedList<Node>();
q.add(root.left);
q.add(root.right);
// We process two nodes at a time, so we
// need two variables to store two front
// items of queue
Node first = null, second = null;
// traversal loop
while (!q.isEmpty())
{
// Pop two items from queue
first = q.peek();
q.poll();
second = q.peek();
q.poll();
// Push first and second node's children
// in reverse order
s.push(second.left);
s.push(first.right);
s.push(second.right);
s.push(first.left);
// If first and second have grandchildren,
// enqueue them in specific order
if (first.left.left != null)
{
q.add(first.right);
q.add(second.left);
q.add(first.left);
q.add(second.right);
}
}
}
/* Given a perfect binary tree, print its nodes in
specific level order */
void printSpecificLevelOrder(Node root)
{
//create a stack and push root
Stack<Node> s = new Stack<Node>();
//Push level 1 and level 2 nodes in stack
s.push(root);
// Since it is perfect Binary Tree, right is
// not checked
if (root.left != null)
{
s.push(root.right);
s.push(root.left);
}
// Do anything more if there are nodes at next
// level in given perfect Binary Tree
if (root.left.left != null)
printSpecificLevelOrderUtil(root, s);
// Finally pop all Nodes from stack and prints
// them.
while (!s.empty())
{
System.out.print(s.peek().data + " ");
s.pop();
}
}
// Driver program to test the 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);
tree.root.right.left = new Node(6);
tree.root.right.right = new Node(7);
tree.root.left.left.left = new Node(8);
tree.root.left.left.right = new Node(9);
tree.root.left.right.left = new Node(10);
tree.root.left.right.right = new Node(11);
tree.root.right.left.left = new Node(12);
tree.root.right.left.right = new Node(13);
tree.root.right.right.left = new Node(14);
tree.root.right.right.right = new Node(15);
tree.root.left.left.left.left = new Node(16);
tree.root.left.left.left.right = new Node(17);
tree.root.left.left.right.left = new Node(18);
tree.root.left.left.right.right = new Node(19);
tree.root.left.right.left.left = new Node(20);
tree.root.left.right.left.right = new Node(21);
tree.root.left.right.right.left = new Node(22);
tree.root.left.right.right.right = new Node(23);
tree.root.right.left.left.left = new Node(24);
tree.root.right.left.left.right = new Node(25);
tree.root.right.left.right.left = new Node(26);
tree.root.right.left.right.right = new Node(27);
tree.root.right.right.left.left = new Node(28);
tree.root.right.right.left.right = new Node(29);
tree.root.right.right.right.left = new Node(30);
tree.root.right.right.right.right = new Node(31);
*/
System.out.println("Specific Level Order Traversal "
+ "of Binary Tree is ");
tree.printSpecificLevelOrder(tree.root);
}
}
// This code has been contributed by Mayank Jaiswal(mayank_24)
# Python program for special order traversal
# A binary tree node
class Node:
# Create queue and enqueue left
# and right child of root
s = []
q = []
# Variable to traverse the reversed array
elements = 0
# A constructor for making a new node
def __init__(self, key):
self.data = key
self.left = None
self.right = None
# Given a perfect binary tree print
# its node in specific order
def printSpecificLevelOrder(self, root):
self.s.append(root)
# Pop the element from the list
prnt = self.s.pop(0)
self.q.append(prnt.data)
if prnt.right:
self.s.append(root.right)
if prnt.left:
self.s.append(root.left)
# Traversal loop
while(len(self.s) > 0):
# Pop two items from queue
first = self.s.pop(0)
self.q.append(first.data)
second = self.s.pop(0)
self.q.append(second.data)
# Since it is perfect Binary tree,
# one of the node is needed to be checked
if first.left and second.right and first.right and second.left:
# If first and second have grandchildren,
# enqueue them in reverse order
self.s.append(first.left)
self.s.append(second.right)
self.s.append(first.right)
self.s.append(second.left)
# Give a perfect binary tree print
# its node in reverse order
for elements in reversed(self.q):
print(elements, end=" ")
# Driver Code
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)
root.left.left.left = Node(8)
root.left.left.right = Node(9)
root.left.right.left = Node(10)
root.left.right.right = Node(11)
root.right.left.left = Node(12)
root.right.left.right = Node(13)
root.right.right.left = Node(14)
root.right.right.right = Node(15)
root.left.left.left.left = Node(16)
root.left.left.left.right = Node(17)
root.left.left.right.left = Node(18)
root.left.left.right.right = Node(19)
root.left.right.left.left = Node(20)
root.left.right.left.right = Node(21)
root.left.right.right.left = Node(22)
root.left.right.right.right = Node(23)
root.right.left.left.left = Node(24)
root.right.left.left.right = Node(25)
root.right.left.right.left = Node(26)
root.right.left.right.right = Node(27)
root.right.right.left.left = Node(28)
root.right.right.left.right = Node(29)
root.right.right.right.left = Node(30)
root.right.right.right.right = Node(31)
'''
print("Specific Level Order traversal of "
"binary tree is")
root.printSpecificLevelOrder(root)
# This code is contributed by 'Vaibhav Kumar 12'
// C# program for special order traversal
using System;
using System.Collections.Generic;
/* A binary tree node has data,
pointer to left child and a
pointer to right child */
public class Node
{
public int data;
public Node left, right;
public Node(int data)
{
this.data = data;
left = right = null;
}
}
class GFG
{
public Node root;
public virtual void printSpecificLevelOrderUtil(Node root,
Stack<Node> s)
{
if (root == null)
{
return;
}
// Create a queue and enqueue left
// and right children of root
LinkedList<Node> q = new LinkedList<Node>();
q.AddLast(root.left);
q.AddLast(root.right);
// We process two nodes at a time, so we
// need two variables to store two front
// items of queue
Node first = null, second = null;
// traversal loop
while (q.Count > 0)
{
// Pop two items from queue
first = q.First.Value;
q.RemoveFirst();
second = q.First.Value;
q.RemoveFirst();
// Push first and second node's
// children in reverse order
s.Push(second.left);
s.Push(first.right);
s.Push(second.right);
s.Push(first.left);
// If first and second have grandchildren,
// enqueue them in specific order
if (first.left.left != null)
{
q.AddLast(first.right);
q.AddLast(second.left);
q.AddLast(first.left);
q.AddLast(second.right);
}
}
}
/* Given a perfect binary tree,
print its nodes in specific
level order */
public virtual void printSpecificLevelOrder(Node root)
{
// create a stack and push root
Stack<Node> s = new Stack<Node>();
// Push level 1 and level 2
// nodes in stack
s.Push(root);
// Since it is perfect Binary Tree,
// right is not checked
if (root.left != null)
{
s.Push(root.right);
s.Push(root.left);
}
// Do anything more if there are
// nodes at next level in given
// perfect Binary Tree
if (root.left.left != null)
{
printSpecificLevelOrderUtil(root, s);
}
// Finally pop all Nodes from
// stack and prints them.
while (s.Count > 0)
{
Console.Write(s.Peek().data + " ");
s.Pop();
}
}
// 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);
tree.root.right.left = new Node(6);
tree.root.right.right = new Node(7);
tree.root.left.left.left = new Node(8);
tree.root.left.left.right = new Node(9);
tree.root.left.right.left = new Node(10);
tree.root.left.right.right = new Node(11);
tree.root.right.left.left = new Node(12);
tree.root.right.left.right = new Node(13);
tree.root.right.right.left = new Node(14);
tree.root.right.right.right = new Node(15);
tree.root.left.left.left.left = new Node(16);
tree.root.left.left.left.right = new Node(17);
tree.root.left.left.right.left = new Node(18);
tree.root.left.left.right.right = new Node(19);
tree.root.left.right.left.left = new Node(20);
tree.root.left.right.left.right = new Node(21);
tree.root.left.right.right.left = new Node(22);
tree.root.left.right.right.right = new Node(23);
tree.root.right.left.left.left = new Node(24);
tree.root.right.left.left.right = new Node(25);
tree.root.right.left.right.left = new Node(26);
tree.root.right.left.right.right = new Node(27);
tree.root.right.right.left.left = new Node(28);
tree.root.right.right.left.right = new Node(29);
tree.root.right.right.right.left = new Node(30);
tree.root.right.right.right.right = new Node(31);
*/
Console.WriteLine("Specific Level Order Traversal " +
"of Binary Tree is ");
tree.printSpecificLevelOrder(tree.root);
}
}
// This code is contributed by Shrikant13
<script>
// JavaScript program for special order traversal
class Node
{
constructor(data) {
this.left = null;
this.right = null;
this.data = data;
}
}
let root;
function printSpecificLevelOrderUtil(root, s)
{
if (root == null)
return;
// Create a queue and enqueue left and right
// children of root
let q = [];
q.push(root.left);
q.push(root.right);
// We process two nodes at a time, so we
// need two variables to store two front
// items of queue
let first = null, second = null;
// traversal loop
while (q.length > 0)
{
// Pop two items from queue
first = q[0];
q.shift();
second = q[0];
q.shift();
// Push first and second node's children
// in reverse order
s.push(second.left);
s.push(first.right);
s.push(second.right);
s.push(first.left);
// If first and second have grandchildren,
// enqueue them in specific order
if (first.left.left != null)
{
q.push(first.right);
q.push(second.left);
q.push(first.left);
q.push(second.right);
}
}
}
/* Given a perfect binary tree, print its nodes in
specific level order */
function printSpecificLevelOrder(root)
{
//create a stack and push root
let s = [];
//Push level 1 and level 2 nodes in stack
s.push(root);
// Since it is perfect Binary Tree, right is
// not checked
if (root.left != null)
{
s.push(root.right);
s.push(root.left);
}
// Do anything more if there are nodes at next
// level in given perfect Binary Tree
if (root.left.left != null)
printSpecificLevelOrderUtil(root, s);
// Finally pop all Nodes from stack and prints
// them.
while (s.length > 0)
{
document.write(s[s.length - 1].data + " ");
s.pop();
}
}
root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
document.write("Specific Level Order Traversal "
+ "of Binary Tree is " + "</br>");
printSpecificLevelOrder(root);
</script>
OutputSpecific Level Order traversal of binary tree is
2 3 1
Time complexity: O(n), the time complexity of the above program is O(n) as we traverse each node of the tree exactly once.
Auxiliary Space: O(n), we use a queue and a stack to store the nodes of the tree, which makes the space complexity of the program O(n).
Approach 2: (Using vector)
- We will traverse each level top to down and we will push each level to stack from top to down
- so, that we can have finally down to up printed levels,
- we are having a level in a vector so we can print it in any defined way,
Implementation:
C++
/* C++ program for special order traversal */
#include<bits/stdc++.h>
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;
Node* right;
/* Helper function that allocates a new node with the
given data and NULL left and right pointers. */
Node(int value)
{
data = value;
left = NULL;
right = NULL;
}
};
/* Given a perfect binary tree, print its nodes in
specific level order */
void specific_level_order_traversal(Node* root)
{
//for level order traversal
queue <Node*> q;
// stack to print reverse
stack < vector <int> > s;
q.push(root);
int sz;
while(!q.empty())
{
vector <int> v; //vector to store the level
sz = q.size(); //considering size of the level
for(int i=0;i<sz;++i)
{
Node* temp = q.front();
q.pop();
//push data of the node of a particular level to vector
v.push_back(temp->data);
if(temp->left!=NULL)
q.push(temp->left);
if(temp->right!=NULL)
q.push(temp->right);
}
//push vector containing a level in stack
s.push(v);
}
//print the stack
while(!s.empty())
{
// Finally pop all Nodes from stack and prints
// them.
vector <int> v = s.top();
s.pop();
for(int i=0,j=v.size()-1;i<j;++i)
{
cout<<v[i]<<" "<<v[j]<<" ";
j--;
}
}
//finally print root;
cout<<root->data;
}
// Driver code
int main()
{
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);
root->right->left = new Node(6);
root->right->right = new Node(7);
root->left->left->left = new Node(8);
root->left->left->right = new Node(9);
root->left->right->left = new Node(10);
root->left->right->right = new Node(11);
root->right->left->left = new Node(12);
root->right->left->right = new Node(13);
root->right->right->left = new Node(14);
root->right->right->right = new Node(15);
root->left->left->left->left = new Node(16);
root->left->left->left->right = new Node(17);
root->left->left->right->left = new Node(18);
root->left->left->right->right = new Node(19);
root->left->right->left->left = new Node(20);
root->left->right->left->right = new Node(21);
root->left->right->right->left = new Node(22);
root->left->right->right->right = new Node(23);
root->right->left->left->left = new Node(24);
root->right->left->left->right = new Node(25);
root->right->left->right->left = new Node(26);
root->right->left->right->right = new Node(27);
root->right->right->left->left = new Node(28);
root->right->right->left->right = new Node(29);
root->right->right->right->left = new Node(30);
root->right->right->right->right = new Node(31);*/
cout << "Specific Level Order traversal of binary "
"tree is \n";
specific_level_order_traversal(root);
return 0;
}
// This code is contributed by Rachit Yadav.
// Java program for special order traversal
import java.util.*;
public class GFG
{
/* A binary tree node has data,
pointer to left child and
a pointer to right child */
static class Node
{
int data;
Node left;
Node right;
/* Helper function that allocates
a new node with the given data and
null left and right pointers. */
Node(int value)
{
data = value;
left = null;
right = null;
}
};
/* Given a perfect binary tree,
print its nodes in specific level order */
static void specific_level_order_traversal(Node root)
{
// for level order traversal
Queue <Node> q= new LinkedList<>();
// Stack to print reverse
Stack <Vector<Integer>> s = new Stack<Vector<Integer>>();
q.add(root);
int sz;
while(q.size() > 0)
{
// vector to store the level
Vector<Integer> v = new Vector<Integer>();
sz = q.size(); // considering size of the level
for(int i = 0; i < sz; ++i)
{
Node temp = q.peek();
q.remove();
// push data of the node of a
// particular level to vector
v.add(temp.data);
if(temp.left != null)
q.add(temp.left);
if(temp.right != null)
q.add(temp.right);
}
// push vector containing a level in Stack
s.push(v);
}
// print the Stack
while(s.size() > 0)
{
// Finally pop all Nodes from Stack
// and prints them.
Vector <Integer> v = s.peek();
s.pop();
for(int i = 0, j = v.size() - 1; i < j; ++i)
{
System.out.print(v.get(i) + " " +
v.get(j) + " ");
j--;
}
}
// finally print root;
System.out.println(root.data);
}
// Driver code
public static void main(String args[])
{
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);
root.right.left = new Node(6);
root.right.right = new Node(7);
root.left.left.left = new Node(8);
root.left.left.right = new Node(9);
root.left.right.left = new Node(10);
root.left.right.right = new Node(11);
root.right.left.left = new Node(12);
root.right.left.right = new Node(13);
root.right.right.left = new Node(14);
root.right.right.right = new Node(15);
root.left.left.left.left = new Node(16);
root.left.left.left.right = new Node(17);
root.left.left.right.left = new Node(18);
root.left.left.right.right = new Node(19);
root.left.right.left.left = new Node(20);
root.left.right.left.right = new Node(21);
root.left.right.right.left = new Node(22);
root.left.right.right.right = new Node(23);
root.right.left.left.left = new Node(24);
root.right.left.left.right = new Node(25);
root.right.left.right.left = new Node(26);
root.right.left.right.right = new Node(27);
root.right.right.left.left = new Node(28);
root.right.right.left.right = new Node(29);
root.right.right.right.left = new Node(30);
root.right.right.right.right = new Node(31);*/
System.out.println("Specific Level Order traversal" +
" of binary tree is");
specific_level_order_traversal(root);
}
}
// This code is contributed by Arnab Kundu
# Python program for special order traversal
# Linked List node
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
# Given a perfect binary tree,
# print its nodes in specific level order
def specific_level_order_traversal(root) :
# for level order traversal
q = []
# Stack to print reverse
s = []
q.append(root)
sz = 0
while(len(q) > 0) :
# vector to store the level
v = []
sz = len(q) # considering size of the level
i = 0
while( i < sz) :
temp = q[0]
q.pop(0)
# push data of the node of a
# particular level to vector
v.append(temp.data)
if(temp.left != None) :
q.append(temp.left)
if(temp.right != None) :
q.append(temp.right)
i = i + 1
# push vector containing a level in Stack
s.append(v)
# print the Stack
while(len(s) > 0) :
# Finally pop all Nodes from Stack
# and prints them.
v = s[-1]
s.pop()
i = 0
j = len(v) - 1
while( i < j) :
print(v[i] , " " , v[j] ,end= " ")
j = j - 1
i = i + 1
# finally print root
print(root.data)
# Driver code
root = Node(1)
root.left = Node(2)
root.right = Node(3)
print("Specific Level Order traversal of binary tree is")
specific_level_order_traversal(root)
# This code is contributed by Arnab Kundu
// C# program for special order traversal
using System;
using System.Collections.Generic;
class GFG
{
/* A binary tree node has data,
pointer to left child and
a pointer to right child */
public class Node
{
public int data;
public Node left;
public Node right;
/* Helper function that allocates
a new node with the given data and
null left and right pointers. */
public Node(int value)
{
data = value;
left = null;
right = null;
}
};
/* Given a perfect binary tree,
print its nodes in specific
level order */
static void specific_level_order_traversal(Node root)
{
// for level order traversal
Queue <Node> q = new Queue <Node>();
// Stack to print reverse
Stack <List<int>> s = new Stack<List<int>>();
q.Enqueue(root);
int sz;
while(q.Count > 0)
{
// vector to store the level
List<int> v = new List<int>();
// considering size of the level
sz = q.Count;
for(int i = 0; i < sz; ++i)
{
Node temp = q.Peek();
q.Dequeue();
// push data of the node of a
// particular level to vector
v.Add(temp.data);
if(temp.left != null)
q.Enqueue(temp.left);
if(temp.right != null)
q.Enqueue(temp.right);
}
// push vector containing a level in Stack
s.Push(v);
}
// print the Stack
while(s.Count > 0)
{
// Finally pop all Nodes from Stack
// and prints them.
List<int> v = s.Peek();
s.Pop();
for(int i = 0,
j = v.Count - 1; i < j; ++i)
{
Console.Write(v[i] + " " +
v[j] + " ");
j--;
}
}
// finally print root;
Console.WriteLine(root.data);
}
// Driver code
public static void Main(String []args)
{
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);
root.right.left = new Node(6);
root.right.right = new Node(7);
root.left.left.left = new Node(8);
root.left.left.right = new Node(9);
root.left.right.left = new Node(10);
root.left.right.right = new Node(11);
root.right.left.left = new Node(12);
root.right.left.right = new Node(13);
root.right.right.left = new Node(14);
root.right.right.right = new Node(15);
root.left.left.left.left = new Node(16);
root.left.left.left.right = new Node(17);
root.left.left.right.left = new Node(18);
root.left.left.right.right = new Node(19);
root.left.right.left.left = new Node(20);
root.left.right.left.right = new Node(21);
root.left.right.right.left = new Node(22);
root.left.right.right.right = new Node(23);
root.right.left.left.left = new Node(24);
root.right.left.left.right = new Node(25);
root.right.left.right.left = new Node(26);
root.right.left.right.right = new Node(27);
root.right.right.left.left = new Node(28);
root.right.right.left.right = new Node(29);
root.right.right.right.left = new Node(30);
root.right.right.right.right = new Node(31);*/
Console.WriteLine("Specific Level Order traversal" +
" of binary tree is");
specific_level_order_traversal(root);
}
}
// This code is contributed by Rajput-Ji
<script>
// Javascript program for special order traversal
/* A binary tree node has data,
pointer to left child and
a pointer to right child */
class Node
{
/* Helper function that allocates
a new node with the given data and
null left and right pointers. */
constructor(value)
{
this.data = value;
this.left = null;
this.right = null;
}
};
/* Given a perfect binary tree,
print its nodes in specific
level order */
function specific_level_order_traversal(root)
{
// for level order traversal
var q = [];
// Stack to print reverse
var s = [];
q.push(root);
var sz;
while(q.length > 0)
{
// vector to store the level
var v = [];
// considering size of the level
sz = q.length;
for(var i = 0; i < sz; ++i)
{
var temp = q[0];
q.shift();
// push data of the node of a
// particular level to vector
v.push(temp.data);
if(temp.left != null)
q.push(temp.left);
if(temp.right != null)
q.push(temp.right);
}
// push vector containing a level in Stack
s.push(v);
}
// print the Stack
while(s.length > 0)
{
// Finally pop all Nodes from Stack
// and prints them.
var v = s[s.length-1];
s.pop();
for(var i = 0,
j = v.length - 1; i < j; ++i)
{
document.write(v[i] + " " +
v[j] + " ");
j--;
}
}
// finally print root;
document.write(root.data);
}
// Driver code
var 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);
root.left.left.left = new Node(8);
root.left.left.right = new Node(9);
root.left.right.left = new Node(10);
root.left.right.right = new Node(11);
root.right.left.left = new Node(12);
root.right.left.right = new Node(13);
root.right.right.left = new Node(14);
root.right.right.right = new Node(15);
root.left.left.left.left = new Node(16);
root.left.left.left.right = new Node(17);
root.left.left.right.left = new Node(18);
root.left.left.right.right = new Node(19);
root.left.right.left.left = new Node(20);
root.left.right.left.right = new Node(21);
root.left.right.right.left = new Node(22);
root.left.right.right.right = new Node(23);
root.right.left.left.left = new Node(24);
root.right.left.left.right = new Node(25);
root.right.left.right.left = new Node(26);
root.right.left.right.right = new Node(27);
root.right.right.left.left = new Node(28);
root.right.right.left.right = new Node(29);
root.right.right.right.left = new Node(30);
root.right.right.right.right = new Node(31);*/
document.write("Specific Level Order traversal" +
" of binary tree is<br>");
specific_level_order_traversal(root);
// This code is contributed by itsok.
</script>
OutputSpecific Level Order traversal of binary tree is
2 3 1
Time Complexity: O(n), as we are traversing each node of the binary tree once.
Auxiliary Space: O(n), as we are storing the nodes of each level in a vector and pushing them in a stack.
Similar Reads
Perfect Binary Tree Specific Level Order Traversal
Given a Perfect Binary Tree like below: Print the level order of nodes in following specific manner: 1 2 3 4 7 5 6 8 15 9 14 10 13 11 12 16 31 17 30 18 29 19 28 20 27 21 26 22 25 23 24i.e. print nodes in level order but nodes should be from left and right side alternatively. Here 1st and 2nd levels
15+ min read
Specific Level Order Traversal of Binary Tree
Given a Binary Tree, the task is to perform a Specific Level Order Traversal of the tree such that at each level print 1st element then the last element, then 2nd element and 2nd last element, until all elements of that level are printed and so on.Examples:Input: Output: 5 3 7 2 8 4 6 9 0 5 1 Explan
8 min read
Print Binary Tree levels in sorted order | Set 2 (Using set)
Given a tree, print the level order traversal in sorted order. Examples : Input : 7 / \ 6 5 / \ / \ 4 3 2 1 Output : 7 5 6 1 2 3 4 Input : 7 / \ 16 1 / \ 4 13 Output : 7 1 16 4 13 We have discussed a priority queue based solution in below post.Print Binary Tree levels in sorted order | Set 1 (Using
5 min read
Traversal of Binary Search Tree in downward direction from a specific node
Given a Binary Search Tree with unique node values and a target value. Find the node whose data is equal to the target and return all the descendant (of the target) node's data which are vertically below the target node. Initially, you are at the root node. Note: If the target node is not present in
10 min read
Construct a Perfect Binary Tree from Preorder Traversal
Given an array pre[], representing the Preorder traversal of a Perfect Binary Tree consisting of N nodes, the task is to construct a Perfect Binary Tree from the given Preorder Traversal and return the root of the tree. Examples: Input: pre[] = {1, 2, 4, 5, 3, 6, 7}Output: 1 / \ / \ 2 3 / \ / \ / \
11 min read
Flatten binary tree in order of post-order traversal
Given a binary tree, the task is to flatten it in order of its post-order traversal. In the flattened binary tree, the left node of all the nodes must be NULL. Examples: Input: 5 / \ 3 7 / \ / \ 2 4 6 8 Output: 2 4 3 6 8 7 5 Input: 1 \ 2 \ 3 \ 4 \ 5 Output: 5 4 3 2 1 A simple approach will be to rec
6 min read
Boundary Level order traversal of a Binary Tree
Given a Binary Tree, the task is to print all levels of this tree in Boundary Level order traversal. Boundary Level order traversal: In this traversal, the first element of the level (starting boundary) is printed first, followed by last element (ending boundary). Then the process is repeated for th
11 min read
Sideways traversal of a Complete Binary Tree
Given a Complete Binary Tree, the task is to print the elements in the following pattern. Let's consider the tree to be: The tree is traversed in the following way: The output for the above tree is: 1 3 7 11 10 9 8 4 5 6 2 Approach: The idea is to use the modified breadth first search function to st
15+ min read
Inorder Traversal of Binary Tree
Inorder traversal is a depth-first traversal method that follows this sequence:Left subtree is visited first.Root node is processed next.Right subtree is visited last.How does Inorder Traversal work?Key Properties:If applied to a Binary Search Tree (BST), it returns elements in sorted order.Ensures
5 min read
Flatten Binary Tree in order of Level Order Traversal
Given a Binary Tree, the task is to flatten it in order of Level order traversal of the tree. In the flattened binary tree, the left node of all the nodes must be NULL.Examples: Input: 1 / \ 5 2 / \ / \ 6 4 9 3 Output: 1 5 2 6 4 9 3 Input: 1 \ 2 \ 3 \ 4 \ 5 Output: 1 2 3 4 5 Approach: We will solve
7 min read