Print node at corresponding level in binary tree
Here given code implementation process.
// Java program for
// Print node at corresponding level in binary tree
// Binary Tree node
class TreeNode
{
public int data;
public TreeNode left;
public TreeNode right;
public TreeNode(int data)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
// Queue Node
class QNode
{
public TreeNode n;
public QNode next;
public QNode(TreeNode n)
{
this.n = n;
this.next = null;
}
}
//Define custom queue class
class MyQueue
{
public QNode front;
public QNode rear;
public int size;
public MyQueue()
{
this.front = null;
this.rear = null;
this.size = 0;
}
// Add a new node at last of queue
public void enqueue(TreeNode n)
{
QNode node = new QNode(n);
if (this.front == null)
{
// When first node of queue
this.front = node;
}
else
{
// Add node at last level
this.rear.next = node;
}
this.size++;
this.rear = node;
}
// Delete front node of queue
public void dequeue()
{
if (this.front != null)
{
if (this.rear == this.front)
{
this.rear = null;
this.front = null;
}
else
{
this.front = this.front.next;
}
this.size--;
}
}
public int isSize()
{
return this.size;
}
public boolean isEmpty()
{
if (this.isSize() == 0)
{
return true;
}
return false;
}
public TreeNode peek()
{
if (this.isSize() == 0)
{
return null;
}
else
{
return this.front.n;
}
}
}
// Define Binary Tree
public class BinaryTree
{
public TreeNode root;
public BinaryTree()
{
this.root = null;
}
// Print corresponding node of each level when exist
public void printLevelNode()
{
if (this.root == null)
{
// When tree is empty
return;
}
// Auxiliary queue which is capable to contain a tree level nodes
MyQueue q1 = new MyQueue();
MyQueue q2 = new MyQueue();
// Add root to q1
q1.enqueue(this.root);
// auxiliary temp variable
TreeNode temp = null;
int level = 1;
int count = 1;
System.out.print("\n Middle Element Of Level");
// This loop execute until auxiliary queue q1 and q2 are not empty
while (!q1.isEmpty() || !q2.isEmpty())
{
// Execute loop until q1 queue are not empty
// And store the next level node in q2 queue
while (!q1.isEmpty())
{
// Get top node of q1 queue
temp = q1.peek();
if (level == count)
{
// Display the corresponding level node
System.out.print("\n Level " + level + " : " + temp.data);
}
if (temp.left != null)
{
q2.enqueue(temp.left);
}
if (temp.right != null)
{
q2.enqueue(temp.right);
}
// Remove top element of q1 queue
q1.dequeue();
count++;
}
if (count < level)
{
System.out.print("\n Level " + level + " : None ");
}
// Change level
level++;
count = 1;
// Execute loop until q2 queue are not empty
// And store the next level node in q1 queue
while (!q2.isEmpty())
{
// Get top node of q2 queue
temp = q2.peek();
if (level == count)
{
// Display the corresponding level node
System.out.print("\n Level " + level + " : " + temp.data);
}
if (temp.left != null)
{
q1.enqueue(temp.left);
}
if (temp.right != null)
{
q1.enqueue(temp.right);
}
// Remove top element of q2 queue
q2.dequeue();
count++;
}
if (count < level && count > 1)
{
System.out.print("\n Level " + level + " : None ");
}
count = 1;
// Change level
level++;
}
}
public static void main(String[] args)
{
BinaryTree tree = new BinaryTree();
/*
Create Binary Tree
-----------------
-6
/ \
4 -7
/ \ / \
2 3 1 12
/ / \ / \
6 10 -4 5 9
/ \ \
1 7 8
*/
tree.root = new TreeNode(-6);
tree.root.left = new TreeNode(4);
tree.root.left.right = new TreeNode(3);
tree.root.left.right.left = new TreeNode(10);
tree.root.left.right.left.left = new TreeNode(1);
tree.root.left.right.right = new TreeNode(-4);
tree.root.left.right.right.right = new TreeNode(7);
tree.root.left.left = new TreeNode(2);
tree.root.left.left.left = new TreeNode(6);
tree.root.right = new TreeNode(-7);
tree.root.right.left = new TreeNode(1);
tree.root.right.right = new TreeNode(12);
tree.root.right.right.left = new TreeNode(5);
tree.root.right.right.right = new TreeNode(9);
tree.root.right.right.right.right = new TreeNode(8);
/*
-6 Level 1 : [-6] First node -6
/ \
4 -7 Level 2 : [4,-7] Second node -7
/ \ / \
2 3 1 12 Level 3 : [2,3,1,12] Third node 1
/ / \ / \
6 10 -4 5 9 Level 4 : [6,10,-4,5,9] Fourth node 5
/ \ \
1 7 8 Level 5 : [1,7,8] fifth node None
*/
tree.printLevelNode();
}
}input
Middle Element Of Level
Level 1 : -6
Level 2 : -7
Level 3 : 1
Level 4 : 5
Level 5 : None// Include header file
#include <iostream>
using namespace std;
// C++ program for
// Print node at corresponding level in binary tree
// Binary Tree node
class TreeNode
{
public: int data;
TreeNode *left;
TreeNode *right;
TreeNode(int data)
{
// Set node value
this->data = data;
this->left = NULL;
this->right = NULL;
}
};
// Queue Node
class QNode
{
public:
TreeNode *n;
QNode *next;
QNode(TreeNode *n)
{
this->n = n;
this->next = NULL;
}
};
//Define custom queue class
class MyQueue
{
public:
QNode *front;
QNode *rear;
int size;
MyQueue()
{
this->front = NULL;
this->rear = NULL;
this->size = 0;
}
// Add a new node at last of queue
void enqueue(TreeNode *n)
{
QNode *node = new QNode(n);
if (this->front == NULL)
{
// When first node of queue
this->front = node;
}
else
{
// Add node at last level
this->rear->next = node;
}
this->size++;
this->rear = node;
}
// Delete front node of queue
void dequeue()
{
if (this->front != NULL)
{
if (this->rear == this->front)
{
this->rear = NULL;
this->front = NULL;
}
else
{
this->front = this->front->next;
}
this->size--;
}
}
int isSize()
{
return this->size;
}
bool isEmpty()
{
if (this->isSize() == 0)
{
return true;
}
return false;
}
TreeNode *peek()
{
if (this->isSize() == 0)
{
return NULL;
}
else
{
return this->front->n;
}
}
};
// Define Binary Tree
class BinaryTree
{
public:
TreeNode *root;
BinaryTree()
{
this->root = NULL;
}
// Print corresponding node of each level when exist
void printLevelNode()
{
if (this->root == NULL)
{
// When tree is empty
return;
}
// Auxiliary queue which is capable to contain a tree level nodes
MyQueue *q1 = new MyQueue();
MyQueue *q2 = new MyQueue();
// Add root to q1
q1->enqueue(this->root);
// auxiliary temp variable
TreeNode *temp = NULL;
int level = 1;
int count = 1;
cout << "\n Middle Element Of Level";
// This loop execute until auxiliary queue q1 and q2 are not empty
while (!q1->isEmpty() || !q2->isEmpty())
{
// Execute loop until q1 queue are not empty
// And store the next level node in q2 queue
while (!q1->isEmpty())
{
// Get top node of q1 queue
temp = q1->peek();
if (level == count)
{
// Display the corresponding level node
cout << "\n Level " << level << " : " << temp->data;
}
if (temp->left != NULL)
{
q2->enqueue(temp->left);
}
if (temp->right != NULL)
{
q2->enqueue(temp->right);
}
// Remove top element of q1 queue
q1->dequeue();
count++;
}
if (count < level)
{
cout << "\n Level " << level << " : None ";
}
// Change level
level++;
count = 1;
// Execute loop until q2 queue are not empty
// And store the next level node in q1 queue
while (!q2->isEmpty())
{
// Get top node of q2 queue
temp = q2->peek();
if (level == count)
{
// Display the corresponding level node
cout << "\n Level " << level << " : " << temp->data;
}
if (temp->left != NULL)
{
q1->enqueue(temp->left);
}
if (temp->right != NULL)
{
q1->enqueue(temp->right);
}
// Remove top element of q2 queue
q2->dequeue();
count++;
}
if (count < level && count > 1)
{
cout << "\n Level " << level << " : None ";
}
count = 1;
// Change level
level++;
}
}
};
int main()
{
BinaryTree *tree = new BinaryTree();
/*
Create Binary Tree
-----------------
-6
/ \
4 -7
/ \ / \
2 3 1 12
/ / \ / \
6 10 -4 5 9
/ \ \
1 7 8
*/
tree->root = new TreeNode(-6);
tree->root->left = new TreeNode(4);
tree->root->left->right = new TreeNode(3);
tree->root->left->right->left = new TreeNode(10);
tree->root->left->right->left->left = new TreeNode(1);
tree->root->left->right->right = new TreeNode(-4);
tree->root->left->right->right->right = new TreeNode(7);
tree->root->left->left = new TreeNode(2);
tree->root->left->left->left = new TreeNode(6);
tree->root->right = new TreeNode(-7);
tree->root->right->left = new TreeNode(1);
tree->root->right->right = new TreeNode(12);
tree->root->right->right->left = new TreeNode(5);
tree->root->right->right->right = new TreeNode(9);
tree->root->right->right->right->right = new TreeNode(8);
/*
-6 Level 1 : [-6] First node -6
/ \
4 -7 Level 2 : [4,-7] Second node -7
/ \ / \
2 3 1 12 Level 3 : [2,3,1,12] Third node 1
/ / \ / \
6 10 -4 5 9 Level 4 : [6,10,-4,5,9] Fourth node 5
/ \ \
1 7 8 Level 5 : [1,7,8] fifth node None
*/
tree->printLevelNode();
return 0;
}input
Middle Element Of Level
Level 1 : -6
Level 2 : -7
Level 3 : 1
Level 4 : 5
Level 5 : None// Include namespace system
using System;
// Csharp program for
// Print node at corresponding level in binary tree
// Binary Tree node
public class TreeNode
{
public int data;
public TreeNode left;
public TreeNode right;
public TreeNode(int data)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
// Queue Node
public class QNode
{
public TreeNode n;
public QNode next;
public QNode(TreeNode n)
{
this.n = n;
this.next = null;
}
}
//Define custom queue class
public class MyQueue
{
public QNode front;
public QNode rear;
public int size;
public MyQueue()
{
this.front = null;
this.rear = null;
this.size = 0;
}
// Add a new node at last of queue
public void enqueue(TreeNode n)
{
QNode node = new QNode(n);
if (this.front == null)
{
// When first node of queue
this.front = node;
}
else
{
// Add node at last level
this.rear.next = node;
}
this.size++;
this.rear = node;
}
// Delete front node of queue
public void dequeue()
{
if (this.front != null)
{
if (this.rear == this.front)
{
this.rear = null;
this.front = null;
}
else
{
this.front = this.front.next;
}
this.size--;
}
}
public int isSize()
{
return this.size;
}
public Boolean isEmpty()
{
if (this.isSize() == 0)
{
return true;
}
return false;
}
public TreeNode peek()
{
if (this.isSize() == 0)
{
return null;
}
else
{
return this.front.n;
}
}
}
// Define Binary Tree
public class BinaryTree
{
public TreeNode root;
public BinaryTree()
{
this.root = null;
}
// Print corresponding node of each level when exist
public void printLevelNode()
{
if (this.root == null)
{
// When tree is empty
return;
}
// Auxiliary queue which is capable to contain a tree level nodes
MyQueue q1 = new MyQueue();
MyQueue q2 = new MyQueue();
// Add root to q1
q1.enqueue(this.root);
// auxiliary temp variable
TreeNode temp = null;
int level = 1;
int count = 1;
Console.Write("\n Middle Element Of Level");
// This loop execute until auxiliary queue q1 and q2 are not empty
while (!q1.isEmpty() || !q2.isEmpty())
{
// Execute loop until q1 queue are not empty
// And store the next level node in q2 queue
while (!q1.isEmpty())
{
// Get top node of q1 queue
temp = q1.peek();
if (level == count)
{
// Display the corresponding level node
Console.Write("\n Level " + level + " : " + temp.data);
}
if (temp.left != null)
{
q2.enqueue(temp.left);
}
if (temp.right != null)
{
q2.enqueue(temp.right);
}
// Remove top element of q1 queue
q1.dequeue();
count++;
}
if (count < level)
{
Console.Write("\n Level " + level + " : None ");
}
// Change level
level++;
count = 1;
// Execute loop until q2 queue are not empty
// And store the next level node in q1 queue
while (!q2.isEmpty())
{
// Get top node of q2 queue
temp = q2.peek();
if (level == count)
{
// Display the corresponding level node
Console.Write("\n Level " + level + " : " + temp.data);
}
if (temp.left != null)
{
q1.enqueue(temp.left);
}
if (temp.right != null)
{
q1.enqueue(temp.right);
}
// Remove top element of q2 queue
q2.dequeue();
count++;
}
if (count < level && count > 1)
{
Console.Write("\n Level " + level + " : None ");
}
count = 1;
// Change level
level++;
}
}
public static void Main(String[] args)
{
BinaryTree tree = new BinaryTree();
/*
Create Binary Tree
-----------------
-6
/ \
4 -7
/ \ / \
2 3 1 12
/ / \ / \
6 10 -4 5 9
/ \ \
1 7 8
*/
tree.root = new TreeNode(-6);
tree.root.left = new TreeNode(4);
tree.root.left.right = new TreeNode(3);
tree.root.left.right.left = new TreeNode(10);
tree.root.left.right.left.left = new TreeNode(1);
tree.root.left.right.right = new TreeNode(-4);
tree.root.left.right.right.right = new TreeNode(7);
tree.root.left.left = new TreeNode(2);
tree.root.left.left.left = new TreeNode(6);
tree.root.right = new TreeNode(-7);
tree.root.right.left = new TreeNode(1);
tree.root.right.right = new TreeNode(12);
tree.root.right.right.left = new TreeNode(5);
tree.root.right.right.right = new TreeNode(9);
tree.root.right.right.right.right = new TreeNode(8);
/*
-6 Level 1 : [-6] First node -6
/ \
4 -7 Level 2 : [4,-7] Second node -7
/ \ / \
2 3 1 12 Level 3 : [2,3,1,12] Third node 1
/ / \ / \
6 10 -4 5 9 Level 4 : [6,10,-4,5,9] Fourth node 5
/ \ \
1 7 8 Level 5 : [1,7,8] fifth node None
*/
tree.printLevelNode();
}
}input
Middle Element Of Level
Level 1 : -6
Level 2 : -7
Level 3 : 1
Level 4 : 5
Level 5 : None<?php
// Php program for
// Print node at corresponding level in binary tree
// Binary Tree node
class TreeNode
{
public $data;
public $left;
public $right;
public function __construct($data)
{
// Set node value
$this->data = $data;
$this->left = NULL;
$this->right = NULL;
}
}
// Queue Node
class QNode
{
public $n;
public $next;
public function __construct($n)
{
$this->n = $n;
$this->next = NULL;
}
}
//Define custom queue class
class MyQueue
{
public $front;
public $rear;
public $size;
public function __construct()
{
$this->front = NULL;
$this->rear = NULL;
$this->size = 0;
}
// Add a new node at last of queue
public function enqueue($n)
{
$node = new QNode($n);
if ($this->front == NULL)
{
// When first node of queue
$this->front = $node;
}
else
{
// Add node at last level
$this->rear->next = $node;
}
$this->size++;
$this->rear = $node;
}
// Delete front node of queue
public function dequeue()
{
if ($this->front != NULL)
{
if ($this->rear == $this->front)
{
$this->rear = NULL;
$this->front = NULL;
}
else
{
$this->front = $this->front->next;
}
$this->size--;
}
}
public function isSize()
{
return $this->size;
}
public function isEmpty()
{
if ($this->isSize() == 0)
{
return true;
}
return false;
}
public function peek()
{
if ($this->isSize() == 0)
{
return NULL;
}
else
{
return $this->front->n;
}
}
}
// Define Binary Tree
class BinaryTree
{
public $root;
public function __construct()
{
$this->root = NULL;
}
// Print corresponding node of each level when exist
public function printLevelNode()
{
if ($this->root == NULL)
{
// When tree is empty
return;
}
// Auxiliary queue which is capable to contain a tree level nodes
$q1 = new MyQueue();
$q2 = new MyQueue();
// Add root to q1
$q1->enqueue($this->root);
// auxiliary temp variable
$temp = NULL;
$level = 1;
$count = 1;
echo("\n Middle Element Of Level");
// This loop execute until auxiliary queue q1 and q2 are not empty
while (!$q1->isEmpty() || !$q2->isEmpty())
{
// Execute loop until q1 queue are not empty
// And store the next level node in q2 queue
while (!$q1->isEmpty())
{
// Get top node of q1 queue
$temp = $q1->peek();
if ($level == $count)
{
// Display the corresponding level node
echo("\n Level ".$level.
" : ".$temp->data);
}
if ($temp->left != NULL)
{
$q2->enqueue($temp->left);
}
if ($temp->right != NULL)
{
$q2->enqueue($temp->right);
}
// Remove top element of q1 queue
$q1->dequeue();
$count++;
}
if ($count < $level)
{
echo("\n Level ".$level.
" : None ");
}
// Change level
$level++;
$count = 1;
// Execute loop until q2 queue are not empty
// And store the next level node in q1 queue
while (!$q2->isEmpty())
{
// Get top node of q2 queue
$temp = $q2->peek();
if ($level == $count)
{
// Display the corresponding level node
echo("\n Level ".$level.
" : ".$temp->data);
}
if ($temp->left != NULL)
{
$q1->enqueue($temp->left);
}
if ($temp->right != NULL)
{
$q1->enqueue($temp->right);
}
// Remove top element of q2 queue
$q2->dequeue();
$count++;
}
if ($count < $level && $count > 1)
{
echo("\n Level ".$level.
" : None ");
}
$count = 1;
// Change level
$level++;
}
}
}
function main()
{
$tree = new BinaryTree();
/*
Create Binary Tree
-----------------
-6
/ \
4 -7
/ \ / \
2 3 1 12
/ / \ / \
6 10 -4 5 9
/ \ \
1 7 8
*/
$tree->root = new TreeNode(-6);
$tree->root->left = new TreeNode(4);
$tree->root->left->right = new TreeNode(3);
$tree->root->left->right->left = new TreeNode(10);
$tree->root->left->right->left->left = new TreeNode(1);
$tree->root->left->right->right = new TreeNode(-4);
$tree->root->left->right->right->right = new TreeNode(7);
$tree->root->left->left = new TreeNode(2);
$tree->root->left->left->left = new TreeNode(6);
$tree->root->right = new TreeNode(-7);
$tree->root->right->left = new TreeNode(1);
$tree->root->right->right = new TreeNode(12);
$tree->root->right->right->left = new TreeNode(5);
$tree->root->right->right->right = new TreeNode(9);
$tree->root->right->right->right->right = new TreeNode(8);
/*
-6 Level 1 : [-6] First node -6
/ \
4 -7 Level 2 : [4,-7] Second node -7
/ \ / \
2 3 1 12 Level 3 : [2,3,1,12] Third node 1
/ / \ / \
6 10 -4 5 9 Level 4 : [6,10,-4,5,9] Fourth node 5
/ \ \
1 7 8 Level 5 : [1,7,8] fifth node None
*/
$tree->printLevelNode();
}
main();input
Middle Element Of Level
Level 1 : -6
Level 2 : -7
Level 3 : 1
Level 4 : 5
Level 5 : None// Node JS program for
// Print node at corresponding level in binary tree
// Binary Tree node
class TreeNode
{
constructor(data)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
// Queue Node
class QNode
{
constructor(n)
{
this.n = n;
this.next = null;
}
}
//Define custom queue class
class MyQueue
{
constructor()
{
this.front = null;
this.rear = null;
this.size = 0;
}
// Add a new node at last of queue
enqueue(n)
{
var node = new QNode(n);
if (this.front == null)
{
// When first node of queue
this.front = node;
}
else
{
// Add node at last level
this.rear.next = node;
}
this.size++;
this.rear = node;
}
// Delete front node of queue
dequeue()
{
if (this.front != null)
{
if (this.rear == this.front)
{
this.rear = null;
this.front = null;
}
else
{
this.front = this.front.next;
}
this.size--;
}
}
isSize()
{
return this.size;
}
isEmpty()
{
if (this.isSize() == 0)
{
return true;
}
return false;
}
peek()
{
if (this.isSize() == 0)
{
return null;
}
else
{
return this.front.n;
}
}
}
// Define Binary Tree
class BinaryTree
{
constructor()
{
this.root = null;
}
// Print corresponding node of each level when exist
printLevelNode()
{
if (this.root == null)
{
// When tree is empty
return;
}
// Auxiliary queue which is capable to contain a tree level nodes
var q1 = new MyQueue();
var q2 = new MyQueue();
// Add root to q1
q1.enqueue(this.root);
// auxiliary temp variable
var temp = null;
var level = 1;
var count = 1;
process.stdout.write("\n Middle Element Of Level");
// This loop execute until auxiliary queue q1 and q2 are not empty
while (!q1.isEmpty() || !q2.isEmpty())
{
// Execute loop until q1 queue are not empty
// And store the next level node in q2 queue
while (!q1.isEmpty())
{
// Get top node of q1 queue
temp = q1.peek();
if (level == count)
{
// Display the corresponding level node
process.stdout.write("\n Level " + level + " : " + temp.data);
}
if (temp.left != null)
{
q2.enqueue(temp.left);
}
if (temp.right != null)
{
q2.enqueue(temp.right);
}
// Remove top element of q1 queue
q1.dequeue();
count++;
}
if (count < level)
{
process.stdout.write("\n Level " + level + " : None ");
}
// Change level
level++;
count = 1;
// Execute loop until q2 queue are not empty
// And store the next level node in q1 queue
while (!q2.isEmpty())
{
// Get top node of q2 queue
temp = q2.peek();
if (level == count)
{
// Display the corresponding level node
process.stdout.write("\n Level " + level + " : " + temp.data);
}
if (temp.left != null)
{
q1.enqueue(temp.left);
}
if (temp.right != null)
{
q1.enqueue(temp.right);
}
// Remove top element of q2 queue
q2.dequeue();
count++;
}
if (count < level && count > 1)
{
process.stdout.write("\n Level " + level + " : None ");
}
count = 1;
// Change level
level++;
}
}
}
function main()
{
var tree = new BinaryTree();
/*
Create Binary Tree
-----------------
-6
/ \
4 -7
/ \ / \
2 3 1 12
/ / \ / \
6 10 -4 5 9
/ \ \
1 7 8
*/
tree.root = new TreeNode(-6);
tree.root.left = new TreeNode(4);
tree.root.left.right = new TreeNode(3);
tree.root.left.right.left = new TreeNode(10);
tree.root.left.right.left.left = new TreeNode(1);
tree.root.left.right.right = new TreeNode(-4);
tree.root.left.right.right.right = new TreeNode(7);
tree.root.left.left = new TreeNode(2);
tree.root.left.left.left = new TreeNode(6);
tree.root.right = new TreeNode(-7);
tree.root.right.left = new TreeNode(1);
tree.root.right.right = new TreeNode(12);
tree.root.right.right.left = new TreeNode(5);
tree.root.right.right.right = new TreeNode(9);
tree.root.right.right.right.right = new TreeNode(8);
/*
-6 Level 1 : [-6] First node -6
/ \
4 -7 Level 2 : [4,-7] Second node -7
/ \ / \
2 3 1 12 Level 3 : [2,3,1,12] Third node 1
/ / \ / \
6 10 -4 5 9 Level 4 : [6,10,-4,5,9] Fourth node 5
/ \ \
1 7 8 Level 5 : [1,7,8] fifth node None
*/
tree.printLevelNode();
}
main();input
Middle Element Of Level
Level 1 : -6
Level 2 : -7
Level 3 : 1
Level 4 : 5
Level 5 : None# Python 3 program for
# Print node at corresponding level in binary tree
# Binary Tree node
class TreeNode :
def __init__(self, data) :
# Set node value
self.data = data
self.left = None
self.right = None
# Queue Node
class QNode :
def __init__(self, n) :
self.n = n
self.next = None
# Define custom queue class
class MyQueue :
def __init__(self) :
self.front = None
self.rear = None
self.size = 0
# Add a new node at last of queue
def enqueue(self, n) :
node = QNode(n)
if (self.front == None) :
# When first node of queue
self.front = node
else :
# Add node at last level
self.rear.next = node
self.size += 1
self.rear = node
# Delete front node of queue
def dequeue(self) :
if (self.front != None) :
if (self.rear == self.front) :
self.rear = None
self.front = None
else :
self.front = self.front.next
self.size -= 1
def isSize(self) :
return self.size
def isEmpty(self) :
if (self.isSize() == 0) :
return True
return False
def peek(self) :
if (self.isSize() == 0) :
return None
else :
return self.front.n
# Define Binary Tree
class BinaryTree :
def __init__(self) :
self.root = None
# Print corresponding node of each level when exist
def printLevelNode(self) :
if (self.root == None) :
# When tree is empty
return
# Auxiliary queue which is capable to contain a tree level nodes
q1 = MyQueue()
q2 = MyQueue()
# Add root to q1
q1.enqueue(self.root)
# auxiliary temp variable
temp = None
level = 1
count = 1
print("\n Middle Element Of Level", end = "")
# This loop execute until auxiliary queue q1 and q2 are not empty
while (not q1.isEmpty() or not q2.isEmpty()) :
# Execute loop until q1 queue are not empty
# And store the next level node in q2 queue
while (not q1.isEmpty()) :
# Get top node of q1 queue
temp = q1.peek()
if (level == count) :
# Display the corresponding level node
print("\n Level ", level ," : ", temp.data, end = "")
if (temp.left != None) :
q2.enqueue(temp.left)
if (temp.right != None) :
q2.enqueue(temp.right)
# Remove top element of q1 queue
q1.dequeue()
count += 1
if (count < level) :
print("\n Level ", level ," : None ", end = "")
# Change level
level += 1
count = 1
# Execute loop until q2 queue are not empty
# And store the next level node in q1 queue
while (not q2.isEmpty()) :
# Get top node of q2 queue
temp = q2.peek()
if (level == count) :
# Display the corresponding level node
print("\n Level ", level ," : ", temp.data, end = "")
if (temp.left != None) :
q1.enqueue(temp.left)
if (temp.right != None) :
q1.enqueue(temp.right)
# Remove top element of q2 queue
q2.dequeue()
count += 1
if (count < level and count > 1) :
print("\n Level ", level ," : None ", end = "")
count = 1
# Change level
level += 1
def main() :
tree = BinaryTree()
# Create Binary Tree
# -----------------
# -6
# / \
# 4 -7
# / \ / \
# 2 3 1 12
# / / \ / \
# 6 10 -4 5 9
# / \ \
# 1 7 8
tree.root = TreeNode(-6)
tree.root.left = TreeNode(4)
tree.root.left.right = TreeNode(3)
tree.root.left.right.left = TreeNode(10)
tree.root.left.right.left.left = TreeNode(1)
tree.root.left.right.right = TreeNode(-4)
tree.root.left.right.right.right = TreeNode(7)
tree.root.left.left = TreeNode(2)
tree.root.left.left.left = TreeNode(6)
tree.root.right = TreeNode(-7)
tree.root.right.left = TreeNode(1)
tree.root.right.right = TreeNode(12)
tree.root.right.right.left = TreeNode(5)
tree.root.right.right.right = TreeNode(9)
tree.root.right.right.right.right = TreeNode(8)
# -6 Level 1 : [-6] First node -6
# / \
# 4 -7 Level 2 : [4,-7] Second node -7
# / \ / \
# 2 3 1 12 Level 3 : [2,3,1,12] Third node 1
# / / \ / \
# 6 10 -4 5 9 Level 4 : [6,10,-4,5,9] Fourth node 5
# / \ \
# 1 7 8 Level 5 : [1,7,8] fifth node None
tree.printLevelNode()
if __name__ == "__main__": main()input
Middle Element Of Level
Level 1 : -6
Level 2 : -7
Level 3 : 1
Level 4 : 5
Level 5 : None# Ruby program for
# Print node at corresponding level in binary tree
# Binary Tree node
class TreeNode
# Define the accessor and reader of class TreeNode
attr_reader :data, :left, :right
attr_accessor :data, :left, :right
def initialize(data)
# Set node value
self.data = data
self.left = nil
self.right = nil
end
end
# Queue Node
class QNode
# Define the accessor and reader of class QNode
attr_reader :n, :next
attr_accessor :n, :next
def initialize(n)
self.n = n
self.next = nil
end
end
# Define custom queue class
class MyQueue
# Define the accessor and reader of class MyQueue
attr_reader :front, :rear, :size
attr_accessor :front, :rear, :size
def initialize()
self.front = nil
self.rear = nil
self.size = 0
end
# Add a new node at last of queue
def enqueue(n)
node = QNode.new(n)
if (self.front == nil)
# When first node of queue
self.front = node
else
# Add node at last level
self.rear.next = node
end
self.size += 1
self.rear = node
end
# Delete front node of queue
def dequeue()
if (self.front != nil)
if (self.rear == self.front)
self.rear = nil
self.front = nil
else
self.front = self.front.next
end
self.size -= 1
end
end
def isSize()
return self.size
end
def isEmpty()
if (self.isSize() == 0)
return true
end
return false
end
def peek()
if (self.isSize() == 0)
return nil
else
return self.front.n
end
end
end
# Define Binary Tree
class BinaryTree
# Define the accessor and reader of class BinaryTree
attr_reader :root
attr_accessor :root
def initialize()
self.root = nil
end
# Print corresponding node of each level when exist
def printLevelNode()
if (self.root == nil)
# When tree is empty
return
end
# Auxiliary queue which is capable to contain a tree level nodes
q1 = MyQueue.new()
q2 = MyQueue.new()
# Add root to q1
q1.enqueue(self.root)
# auxiliary temp variable
temp = nil
level = 1
count = 1
print("\n Middle Element Of Level")
# This loop execute until auxiliary queue q1 and q2 are not empty
while (!q1.isEmpty() || !q2.isEmpty())
# Execute loop until q1 queue are not empty
# And store the next level node in q2 queue
while (!q1.isEmpty())
# Get top node of q1 queue
temp = q1.peek()
if (level == count)
# Display the corresponding level node
print("\n Level ", level ," : ", temp.data)
end
if (temp.left != nil)
q2.enqueue(temp.left)
end
if (temp.right != nil)
q2.enqueue(temp.right)
end
# Remove top element of q1 queue
q1.dequeue()
count += 1
end
if (count < level)
print("\n Level ", level ," : None ")
end
# Change level
level += 1
count = 1
# Execute loop until q2 queue are not empty
# And store the next level node in q1 queue
while (!q2.isEmpty())
# Get top node of q2 queue
temp = q2.peek()
if (level == count)
# Display the corresponding level node
print("\n Level ", level ," : ", temp.data)
end
if (temp.left != nil)
q1.enqueue(temp.left)
end
if (temp.right != nil)
q1.enqueue(temp.right)
end
# Remove top element of q2 queue
q2.dequeue()
count += 1
end
if (count < level && count > 1)
print("\n Level ", level ," : None ")
end
count = 1
# Change level
level += 1
end
end
end
def main()
tree = BinaryTree.new()
# Create Binary Tree
# -----------------
# -6
# / \
# 4 -7
# / \ / \
# 2 3 1 12
# / / \ / \
# 6 10 -4 5 9
# / \ \
# 1 7 8
tree.root = TreeNode.new(-6)
tree.root.left = TreeNode.new(4)
tree.root.left.right = TreeNode.new(3)
tree.root.left.right.left = TreeNode.new(10)
tree.root.left.right.left.left = TreeNode.new(1)
tree.root.left.right.right = TreeNode.new(-4)
tree.root.left.right.right.right = TreeNode.new(7)
tree.root.left.left = TreeNode.new(2)
tree.root.left.left.left = TreeNode.new(6)
tree.root.right = TreeNode.new(-7)
tree.root.right.left = TreeNode.new(1)
tree.root.right.right = TreeNode.new(12)
tree.root.right.right.left = TreeNode.new(5)
tree.root.right.right.right = TreeNode.new(9)
tree.root.right.right.right.right = TreeNode.new(8)
# -6 Level 1 : [-6] First node -6
# / \
# 4 -7 Level 2 : [4,-7] Second node -7
# / \ / \
# 2 3 1 12 Level 3 : [2,3,1,12] Third node 1
# / / \ / \
# 6 10 -4 5 9 Level 4 : [6,10,-4,5,9] Fourth node 5
# / \ \
# 1 7 8 Level 5 : [1,7,8] fifth node None
tree.printLevelNode()
end
main()input
Middle Element Of Level
Level 1 : -6
Level 2 : -7
Level 3 : 1
Level 4 : 5
Level 5 : None // Scala program for
// Print node at corresponding level in binary tree
// Binary Tree node
class TreeNode(var data: Int , var left: TreeNode , var right: TreeNode)
{
def this(data: Int)
{
// Set node value
this(data,null,null);
}
}
// Queue Node
class QNode(var n: TreeNode , var next: QNode)
{
def this(n: TreeNode)
{
this(n,null);
}
}
//Define custom queue class
class MyQueue(var front: QNode , var rear: QNode , var size: Int)
{
def this()
{
this(null,null,0);
}
// Add a new node at last of queue
def enqueue(n: TreeNode): Unit = {
var node: QNode = new QNode(n);
if (this.front == null)
{
// When first node of queue
this.front = node;
}
else
{
// Add node at last level
this.rear.next = node;
}
this.size += 1;
this.rear = node;
}
// Delete front node of queue
def dequeue(): Unit = {
if (this.front != null)
{
if (this.rear == this.front)
{
this.rear = null;
this.front = null;
}
else
{
this.front = this.front.next;
}
this.size -= 1;
}
}
def isSize(): Int = {
return this.size;
}
def isEmpty(): Boolean = {
if (this.isSize() == 0)
{
return true;
}
return false;
}
def peek(): TreeNode = {
if (this.isSize() == 0)
{
return null;
}
else
{
return this.front.n;
}
}
}
// Define Binary Tree
class BinaryTree(var root: TreeNode)
{
def this()
{
this(null);
}
// Print corresponding node of each level when exist
def printLevelNode(): Unit = {
if (this.root == null)
{
// When tree is empty
return;
}
// Auxiliary queue which is capable to contain a tree level nodes
var q1: MyQueue = new MyQueue();
var q2: MyQueue = new MyQueue();
// Add root to q1
q1.enqueue(this.root);
// auxiliary temp variable
var temp: TreeNode = null;
var level: Int = 1;
var count: Int = 1;
print("\n Middle Element Of Level");
// This loop execute until auxiliary queue q1 and q2 are not empty
while (!q1.isEmpty() || !q2.isEmpty())
{
// Execute loop until q1 queue are not empty
// And store the next level node in q2 queue
while (!q1.isEmpty())
{
// Get top node of q1 queue
temp = q1.peek();
if (level == count)
{
// Display the corresponding level node
print("\n Level " + level + " : " + temp.data);
}
if (temp.left != null)
{
q2.enqueue(temp.left);
}
if (temp.right != null)
{
q2.enqueue(temp.right);
}
// Remove top element of q1 queue
q1.dequeue();
count += 1;
}
if (count < level)
{
print("\n Level " + level + " : None ");
}
// Change level
level += 1;
count = 1;
// Execute loop until q2 queue are not empty
// And store the next level node in q1 queue
while (!q2.isEmpty())
{
// Get top node of q2 queue
temp = q2.peek();
if (level == count)
{
// Display the corresponding level node
print("\n Level " + level + " : " + temp.data);
}
if (temp.left != null)
{
q1.enqueue(temp.left);
}
if (temp.right != null)
{
q1.enqueue(temp.right);
}
// Remove top element of q2 queue
q2.dequeue();
count += 1;
}
if (count < level && count > 1)
{
print("\n Level " + level + " : None ");
}
count = 1;
// Change level
level += 1;
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var tree: BinaryTree = new BinaryTree();
/*
Create Binary Tree
-----------------
-6
/ \
4 -7
/ \ / \
2 3 1 12
/ / \ / \
6 10 -4 5 9
/ \ \
1 7 8
*/
tree.root = new TreeNode(-6);
tree.root.left = new TreeNode(4);
tree.root.left.right = new TreeNode(3);
tree.root.left.right.left = new TreeNode(10);
tree.root.left.right.left.left = new TreeNode(1);
tree.root.left.right.right = new TreeNode(-4);
tree.root.left.right.right.right = new TreeNode(7);
tree.root.left.left = new TreeNode(2);
tree.root.left.left.left = new TreeNode(6);
tree.root.right = new TreeNode(-7);
tree.root.right.left = new TreeNode(1);
tree.root.right.right = new TreeNode(12);
tree.root.right.right.left = new TreeNode(5);
tree.root.right.right.right = new TreeNode(9);
tree.root.right.right.right.right = new TreeNode(8);
/*
-6 Level 1 : [-6] First node -6
/ \
4 -7 Level 2 : [4,-7] Second node -7
/ \ / \
2 3 1 12 Level 3 : [2,3,1,12] Third node 1
/ / \ / \
6 10 -4 5 9 Level 4 : [6,10,-4,5,9] Fourth node 5
/ \ \
1 7 8 Level 5 : [1,7,8] fifth node None
*/
tree.printLevelNode();
}
}input
Middle Element Of Level
Level 1 : -6
Level 2 : -7
Level 3 : 1
Level 4 : 5
Level 5 : None// Swift 4 program for
// Print node at corresponding level in binary tree
// Binary Tree node
class TreeNode
{
var data: Int;
var left: TreeNode? ;
var right: TreeNode? ;
init(_ data: Int)
{
// Set node value
self.data = data;
self.left = nil;
self.right = nil;
}
}
// Queue Node
class QNode
{
var n: TreeNode? ;
var next: QNode? ;
init(_ n: TreeNode? )
{
self.n = n;
self.next = nil;
}
}
// Define custom queue class
class MyQueue
{
var front: QNode? ;
var rear: QNode? ;
var size: Int;
init()
{
self.front = nil;
self.rear = nil;
self.size = 0;
}
// Add a new node at last of queue
func enqueue(_ n: TreeNode? )
{
let node: QNode = QNode(n);
if (self.front == nil)
{
// When first node of queue
self.front = node;
}
else
{
// Add node at last level
self.rear!.next = node;
}
self.size += 1;
self.rear = node;
}
// Delete front node of queue
func dequeue()
{
if (self.front != nil)
{
if (self.rear === self.front)
{
self.rear = nil;
self.front = nil;
}
else
{
self.front = self.front!.next;
}
self.size -= 1;
}
}
func isSize()->Int
{
return self.size;
}
func isEmpty()->Bool
{
if (self.isSize() == 0)
{
return true;
}
return false;
}
func peek()->TreeNode?
{
if (self.isSize() == 0)
{
return nil;
}
else
{
return self.front!.n;
}
}
}
// Define Binary Tree
class BinaryTree
{
var root: TreeNode? ;
init()
{
self.root = nil;
}
// Print corresponding node of each level when exist
func printLevelNode()
{
if (self.root == nil)
{
// When tree is empty
return;
}
// Auxiliary queue which is capable to contain a tree level nodes
let q1: MyQueue = MyQueue();
let q2: MyQueue = MyQueue();
// Add root to q1
q1.enqueue(self.root);
// auxiliary temp variable
var temp: TreeNode? = nil;
var level: Int = 1;
var count: Int = 1;
print("\n Middle Element Of Level", terminator: "");
// This loop execute until auxiliary queue q1 and q2 are not empty
while (!q1.isEmpty() || !q2.isEmpty())
{
// Execute loop until q1 queue are not empty
// And store the next level node in q2 queue
while (!q1.isEmpty())
{
// Get top node of q1 queue
temp = q1.peek();
if (level == count)
{
// Display the corresponding level node
print("\n Level ", level ," : ", temp!.data, terminator: "");
}
if (temp!.left != nil)
{
q2.enqueue(temp!.left);
}
if (temp!.right != nil)
{
q2.enqueue(temp!.right);
}
// Remove top element of q1 queue
q1.dequeue();
count += 1;
}
if (count < level)
{
print("\n Level ", level ," : None ", terminator: "");
}
// Change level
level += 1;
count = 1;
// Execute loop until q2 queue are not empty
// And store the next level node in q1 queue
while (!q2.isEmpty())
{
// Get top node of q2 queue
temp = q2.peek();
if (level == count)
{
// Display the corresponding level node
print("\n Level ", level ," : ", temp!.data, terminator: "");
}
if (temp!.left != nil)
{
q1.enqueue(temp!.left);
}
if (temp!.right != nil)
{
q1.enqueue(temp!.right);
}
// Remove top element of q2 queue
q2.dequeue();
count += 1;
}
if (count < level && count > 1)
{
print("\n Level ", level ," : None ", terminator: "");
}
count = 1;
// Change level
level += 1;
}
}
}
func main()
{
let tree: BinaryTree = BinaryTree();
/*
Create Binary Tree
-----------------
-6
/ \
4 -7
/ \ / \
2 3 1 12
/ / \ / \
6 10 -4 5 9
/ \ \
1 7 8
*/
tree.root = TreeNode(-6);
tree.root!.left = TreeNode(4);
tree.root!.left!.right = TreeNode(3);
tree.root!.left!.right!.left = TreeNode(10);
tree.root!.left!.right!.left!.left = TreeNode(1);
tree.root!.left!.right!.right = TreeNode(-4);
tree.root!.left!.right!.right!.right = TreeNode(7);
tree.root!.left!.left = TreeNode(2);
tree.root!.left!.left!.left = TreeNode(6);
tree.root!.right = TreeNode(-7);
tree.root!.right!.left = TreeNode(1);
tree.root!.right!.right = TreeNode(12);
tree.root!.right!.right!.left = TreeNode(5);
tree.root!.right!.right!.right = TreeNode(9);
tree.root!.right!.right!.right!.right = TreeNode(8);
/*
-6 Level 1 : [-6] First node -6
/ \
4 -7 Level 2 : [4,-7] Second node -7
/ \ / \
2 3 1 12 Level 3 : [2,3,1,12] Third node 1
/ / \ / \
6 10 -4 5 9 Level 4 : [6,10,-4,5,9] Fourth node 5
/ \ \
1 7 8 Level 5 : [1,7,8] fifth node None
*/
tree.printLevelNode();
}
main();input
Middle Element Of Level
Level 1 : -6
Level 2 : -7
Level 3 : 1
Level 4 : 5
Level 5 : None// Kotlin program for
// Print node at corresponding level in binary tree
// Binary Tree node
class TreeNode
{
var data: Int;
var left: TreeNode ? ;
var right: TreeNode ? ;
constructor(data: Int)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
// Queue Node
class QNode
{
var n: TreeNode ? ;
var next: QNode ? ;
constructor(n: TreeNode ? )
{
this.n = n;
this.next = null;
}
}
//Define custom queue class
class MyQueue
{
var front: QNode ? ;
var rear: QNode ? ;
var size: Int;
constructor()
{
this.front = null;
this.rear = null;
this.size = 0;
}
// Add a new node at last of queue
fun enqueue(n: TreeNode ? ): Unit
{
val node: QNode = QNode(n);
if (this.front == null)
{
// When first node of queue
this.front = node;
}
else
{
// Add node at last level
this.rear?.next = node;
}
this.size += 1;
this.rear = node;
}
// Delete front node of queue
fun dequeue(): Unit
{
if (this.front != null)
{
if (this.rear == this.front)
{
this.rear = null;
this.front = null;
}
else
{
this.front = this.front?.next;
}
this.size -= 1;
}
}
fun isSize(): Int
{
return this.size;
}
fun isEmpty(): Boolean
{
if (this.isSize() == 0)
{
return true;
}
return false;
}
fun peek(): TreeNode ?
{
if (this.isSize() == 0)
{
return null;
}
else
{
return this.front?.n;
}
}
}
// Define Binary Tree
class BinaryTree
{
var root: TreeNode ? ;
constructor()
{
this.root = null;
}
// Print corresponding node of each level when exist
fun printLevelNode(): Unit
{
if (this.root == null)
{
// When tree is empty
return;
}
// Auxiliary queue which is capable to contain a tree level nodes
val q1: MyQueue = MyQueue();
val q2: MyQueue = MyQueue();
// Add root to q1
q1.enqueue(this.root);
// auxiliary temp variable
var temp: TreeNode ? ;
var level: Int = 1;
var count: Int = 1;
print("\n Middle Element Of Level");
// This loop execute until auxiliary queue q1 and q2 are not empty
while (!q1.isEmpty() || !q2.isEmpty())
{
// Execute loop until q1 queue are not empty
// And store the next level node in q2 queue
while (!q1.isEmpty())
{
// Get top node of q1 queue
temp = q1.peek();
if (level == count)
{
// Display the corresponding level node
print("\n Level " + level + " : " + temp!!.data);
}
if (temp?.left != null)
{
q2.enqueue(temp.left);
}
if (temp?.right != null)
{
q2.enqueue(temp.right);
}
// Remove top element of q1 queue
q1.dequeue();
count += 1;
}
if (count < level)
{
print("\n Level " + level + " : None ");
}
// Change level
level += 1;
count = 1;
// Execute loop until q2 queue are not empty
// And store the next level node in q1 queue
while (!q2.isEmpty())
{
// Get top node of q2 queue
temp = q2.peek();
if (level == count)
{
// Display the corresponding level node
print("\n Level " + level + " : " + temp!!.data);
}
if (temp?.left != null)
{
q1.enqueue(temp.left);
}
if (temp?.right != null)
{
q1.enqueue(temp.right);
}
// Remove top element of q2 queue
q2.dequeue();
count += 1;
}
if (count < level && count > 1)
{
print("\n Level " + level + " : None ");
}
count = 1;
// Change level
level += 1;
}
}
}
fun main(args: Array < String > ): Unit
{
val tree: BinaryTree = BinaryTree();
/*
Create Binary Tree
-----------------
-6
/ \
4 -7
/ \ / \
2 3 1 12
/ / \ / \
6 10 -4 5 9
/ \ \
1 7 8
*/
tree.root = TreeNode(-6);
tree.root?.left = TreeNode(4);
tree.root?.left?.right = TreeNode(3);
tree.root?.left?.right?.left = TreeNode(10);
tree.root?.left?.right?.left?.left = TreeNode(1);
tree.root?.left?.right?.right = TreeNode(-4);
tree.root?.left?.right?.right?.right = TreeNode(7);
tree.root?.left?.left = TreeNode(2);
tree.root?.left?.left?.left = TreeNode(6);
tree.root?.right = TreeNode(-7);
tree.root?.right?.left = TreeNode(1);
tree.root?.right?.right = TreeNode(12);
tree.root?.right?.right?.left = TreeNode(5);
tree.root?.right?.right?.right = TreeNode(9);
tree.root?.right?.right?.right?.right = TreeNode(8);
/*
-6 Level 1 : [-6] First node -6
/ \
4 -7 Level 2 : [4,-7] Second node -7
/ \ / \
2 3 1 12 Level 3 : [2,3,1,12] Third node 1
/ / \ / \
6 10 -4 5 9 Level 4 : [6,10,-4,5,9] Fourth node 5
/ \ \
1 7 8 Level 5 : [1,7,8] fifth node None
*/
tree.printLevelNode();
}input
Middle Element Of Level
Level 1 : -6
Level 2 : -7
Level 3 : 1
Level 4 : 5
Level 5 : None
Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.
New Comment