Print even positioned nodes of odd levels in level order of the given binary tree
Given a binary tree, the task is to print the even positioned nodes of odd levels in the level order traversal of the tree. The root is considered at level 0, and the leftmost node of any level is considered as a node at position 0.
Example:
Input:
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
/ \
10 11
Output: 2 8
Input:
2
/ \
4 15
/ /
45 17
Output: 4
Prerequisite – Even positioned elements at even level
Approach: To print nodes level by level, use level order traversal. The idea is based on Print level order traversal line by line. For that, traverse nodes level by level and switch odd level flag after every level. Similarly, mark 1st node in every level as even position and switch it after each time the next node is processed.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node *left, *right;
};
void printOddLevelEvenNodes(Node* root)
{
if (root == NULL)
return ;
queue<Node*> q;
q.push(root);
bool evenLevel = true ;
while (1) {
int nodeCount = q.size();
if (nodeCount == 0)
break ;
bool evenNodePosition = true ;
while (nodeCount > 0) {
Node* node = q.front();
if (!evenLevel && evenNodePosition)
cout << node->data << " " ;
q.pop();
if (node->left != NULL)
q.push(node->left);
if (node->right != NULL)
q.push(node->right);
nodeCount--;
evenNodePosition = !evenNodePosition;
}
evenLevel = !evenLevel;
}
}
struct Node* newNode( int data)
{
struct Node* node = new Node;
node->data = data;
node->left = 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);
root->right->left = newNode(6);
root->right->right = newNode(7);
root->left->right->left = newNode(8);
root->left->right->right = newNode(9);
root->left->right->left->left = newNode(10);
root->left->right->right->right = newNode(11);
printOddLevelEvenNodes(root);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static class Node
{
int data;
Node left, right;
};
static void printOddLevelEvenNodes(Node root)
{
if (root == null )
return ;
Queue<Node> q = new LinkedList<>();
q.add(root);
boolean evenLevel = true ;
while ( true )
{
int nodeCount = q.size();
if (nodeCount == 0 )
break ;
boolean evenNodePosition = true ;
while (nodeCount > 0 )
{
Node node = q.peek();
if (!evenLevel && evenNodePosition)
System.out.print(node.data + " " );
q.remove();
if (node.left != null )
q.add(node.left);
if (node.right != null )
q.add(node.right);
nodeCount--;
evenNodePosition = !evenNodePosition;
}
evenLevel = !evenLevel;
}
}
static Node newNode( int data)
{
Node node = new Node();
node.data = data;
node.left = node.right = null ;
return (node);
}
public static void main(String[] args)
{
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.right.left = newNode( 8 );
root.left.right.right = newNode( 9 );
root.left.right.left.left = newNode( 10 );
root.left.right.right.right = newNode( 11 );
printOddLevelEvenNodes(root);
}
}
|
Python3
class newNode:
def __init__( self , key):
self .data = key
self .left = None
self .right = None
def printOddLevelEvenNodes(root):
if (root = = None ):
return
q = []
q.append(root)
evenLevel = True
while ( 1 ):
nodeCount = len (q)
if (nodeCount = = 0 ):
break
evenNodePosition = True
while (nodeCount > 0 ):
node = q[ 0 ]
if not evenLevel and evenNodePosition:
print (node.data, end = " " )
q.pop( 0 )
if (node.left ! = None ):
q.append(node.left)
if (node.right ! = None ):
q.append(node.right)
nodeCount - = 1
evenNodePosition = not evenNodePosition
evenLevel = not evenLevel
if __name__ = = '__main__' :
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.right.left = newNode( 8 )
root.left.right.right = newNode( 9 )
root.left.right.left.left = newNode( 10 )
root.left.right.right.right = newNode( 11 )
printOddLevelEvenNodes(root)
|
C#
using System;
using System.Collections.Generic;
class GFG
{
class Node
{
public int data;
public Node left, right;
};
static void printOddLevelEvenNodes(Node root)
{
if (root == null )
return ;
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
bool evenLevel = true ;
while ( true )
{
int nodeCount = q.Count;
if (nodeCount == 0)
break ;
bool evenNodePosition = true ;
while (nodeCount > 0)
{
Node node = q.Peek();
if (!evenLevel && evenNodePosition)
Console.Write(node.data + " " );
q.Dequeue();
if (node.left != null )
q.Enqueue(node.left);
if (node.right != null )
q.Enqueue(node.right);
nodeCount--;
evenNodePosition = !evenNodePosition;
}
evenLevel = !evenLevel;
}
}
static Node newNode( int data)
{
Node node = new Node();
node.data = data;
node.left = node.right = null ;
return (node);
}
public static void Main(String[] args)
{
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.right.left = newNode(8);
root.left.right.right = newNode(9);
root.left.right.left.left = newNode(10);
root.left.right.right.right = newNode(11);
printOddLevelEvenNodes(root);
}
}
|
Javascript
<script>
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
function printOddLevelEvenNodes(root)
{
if (root == null )
return ;
let q = [];
q.push(root);
let evenLevel = true ;
while ( true )
{
let nodeCount = q.length;
if (nodeCount == 0)
break ;
let evenNodePosition = true ;
while (nodeCount > 0)
{
let node = q[0];
if (!evenLevel && evenNodePosition)
document.write(node.data + " " );
q.shift();
if (node.left != null )
q.push(node.left);
if (node.right != null )
q.push(node.right);
nodeCount--;
evenNodePosition = !evenNodePosition;
}
evenLevel = !evenLevel;
}
}
function newNode(data)
{
let node = new Node(data);
return (node);
}
let 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.right.left = newNode(8);
root.left.right.right = newNode(9);
root.left.right.left.left = newNode(10);
root.left.right.right.right = newNode(11);
printOddLevelEvenNodes(root);
</script>
|
Time Complexity: O(N), where N is number of nodes.
Auxiliary Space: O(N)
Last Updated :
20 Mar, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...