Print extreme nodes of each level of Binary Tree in alternate order
Given a binary tree, print nodes of extreme corners of each level but in alternate order.
Example:
For above tree, the output can be
1 2 7 8 31
- print rightmost node of 1st level
- print leftmost node of 2nd level
- print rightmost node of 3rd level
- print leftmost node of 4th level
- print rightmost node of 5th level
OR
1 3 4 15 16
- print leftmost node of 1st level
- print rightmost node of 2nd level
- print leftmost node of 3rd level
- print rightmost node of 4th level
- print leftmost node of 5th level
The idea is to traverse tree level by level. For each level, we count number of nodes in it and print its leftmost or the rightmost node based on value of a Boolean flag. We dequeue all nodes of current level and enqueue all nodes of next level and invert value of Boolean flag when switching levels.
Below is the implementation of above idea –
C++
#include <bits/stdc++.h>
using namespace std;
struct Node
{
int data;
Node *left, *right;
};
Node* newNode( int data)
{
Node* node = new Node;
node->data = data;
node->right = node->left = NULL;
return node;
}
void printExtremeNodes(Node* root)
{
if (root == NULL)
return ;
queue<Node*> q;
q.push(root);
bool flag = false ;
while (!q.empty())
{
int nodeCount = q.size();
int n = nodeCount;
while (n--)
{
Node* curr = q.front();
if (curr->left)
q.push(curr->left);
if (curr->right)
q.push(curr->right);
q.pop();
if (flag && n == nodeCount - 1)
cout << curr->data << " " ;
if (!flag && n == 0)
cout << curr->data << " " ;
}
flag = !flag;
}
}
int main()
{
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
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->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->right->right->right->right = newNode(31);
printExtremeNodes(root);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static class Node
{
int data;
Node left, right;
};
static Node newNode( int data)
{
Node node = new Node();
node.data = data;
node.right = node.left = null ;
return node;
}
static void printExtremeNodes(Node root)
{
if (root == null )
return ;
Queue<Node> q = new LinkedList<Node>();
q.add(root);
boolean flag = false ;
while (q.size()> 0 )
{
int nodeCount = q.size();
int n = nodeCount;
while (n--> 0 )
{
Node curr = q.peek();
if (curr.left!= null )
q.add(curr.left);
if (curr.right!= null )
q.add(curr.right);
q.remove();
if (flag && n == nodeCount - 1 )
System.out.print( curr.data + " " );
if (!flag && n == 0 )
System.out.print( curr.data + " " );
}
flag = !flag;
}
}
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.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.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.right.right.right.right = newNode( 31 );
printExtremeNodes(root);
}
}
|
Python
class Node:
def __init__( self , key):
self .data = key
self .left = self .right = None
def newNode( data):
temp = Node( 0 )
temp.data = data
temp.left = temp.right = None
return temp
def printExtremeNodes( root):
if (root = = None ):
return
q = []
q.append(root)
flag = False
while ( len (q) > 0 ):
nodeCount = len (q)
n = nodeCount
while (n > 0 ):
n = n - 1
curr = q[ 0 ]
if (curr.left ! = None ):
q.append(curr.left)
if (curr.right ! = None ):
q.append(curr.right)
q.pop( 0 )
if (flag and n = = nodeCount - 1 ):
print ( curr.data , end = " " )
if ( not flag and n = = 0 ):
print ( curr.data ,end = " " )
flag = not flag
root = newNode( 1 )
root.left = newNode( 2 )
root.right = newNode( 3 )
root.left.left = newNode( 4 )
root.left.right = newNode( 5 )
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.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.right.right.right.right = newNode( 31 )
printExtremeNodes(root)
|
C#
using System;
using System.Collections.Generic;
class GFG
{
public class Node
{
public int data;
public Node left, right;
};
static Node newNode( int data)
{
Node node = new Node();
node.data = data;
node.right = node.left = null ;
return node;
}
static void printExtremeNodes(Node root)
{
if (root == null )
return ;
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
Boolean flag = false ;
while (q.Count > 0)
{
int nodeCount = q.Count;
int n = nodeCount;
while (n-->0)
{
Node curr = q.Peek();
if (curr.left != null )
q.Enqueue(curr.left);
if (curr.right != null )
q.Enqueue(curr.right);
q.Dequeue();
if (flag && n == nodeCount - 1)
Console.Write( curr.data + " " );
if (!flag && n == 0)
Console.Write( curr.data + " " );
}
flag = !flag;
}
}
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.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.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.right.right.right.right = newNode(31);
printExtremeNodes(root);
}
}
|
Javascript
<script>
class Node
{
constructor()
{
this .data = 0;
this .left = null ;
this .right = null ;
}
};
function newNode(data)
{
var node = new Node();
node.data = data;
node.right = node.left = null ;
return node;
}
function printExtremeNodes(root)
{
if (root == null )
return ;
var q = [];
q.push(root);
var flag = false ;
while (q.length > 0)
{
var nodeCount = q.length;
var n = nodeCount;
while (n-->0)
{
var curr = q[0];
if (curr.left != null )
q.push(curr.left);
if (curr.right != null )
q.push(curr.right);
q.shift();
if (flag && n == nodeCount - 1)
document.write( curr.data + " " );
if (!flag && n == 0)
document.write( curr.data + " " );
}
flag = !flag;
}
}
var root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
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.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.right.right.right.right = newNode(31);
printExtremeNodes(root);
</script>
|
Time complexity: O(n) where n is the total number of nodes in given binary tree.
Auxiliary Space: O(n) where n is the total number of nodes in given binary tree due to queue.
Exercise – Print nodes of extreme corners of each level from bottom to top in alternate order.
Last Updated :
05 Jan, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...