Given a Binary tree, the task is to print all the internal nodes in a tree.
An internal node is a node which carries at least one child or in other words, an internal node is not a leaf node. Here we intend to print all such internal nodes in level order. Consider the following Binary Tree:
Input:
Output: 15 10 20
The way to solve this involves a BFS of the tree. The algorithm is as follows:
- Do a level order traversal by pushing nodes in the queue one by one.
- Pop the elements from the queue one by one and keep a track of following cases:
- The node has a left child only.
- The node has a right child only.
- The node has both left and right child.
- The node has no children at all.
- Except for case 4, print the data in the node for all the other 3 cases.
Below is the implementation of the above approach:
C++
// C++ program to print all internal // nodes in tree #include <bits/stdc++.h> using namespace std;
// A node in the Binary tree struct Node {
int data;
Node *left, *right;
Node( int data)
{
left = right = NULL;
this ->data = data;
}
}; // Function to print all internal nodes // in level order from left to right void printInternalNodes(Node* root)
{ // Using a queue for a level order traversal
queue<Node*> q;
q.push(root);
while (!q.empty()) {
// Check and pop the element in
// the front of the queue
Node* curr = q.front();
q.pop();
// The variable flag keeps track of
// whether a node is an internal node
bool isInternal = 0;
// The node has a left child
if (curr->left) {
isInternal = 1;
q.push(curr->left);
}
// The node has a right child
if (curr->right) {
isInternal = 1;
q.push(curr->right);
}
// In case the node has either a left
// or right child or both print the data
if (isInternal)
cout << curr->data << " " ;
}
} // Driver program to build a sample tree int main()
{ Node* root = new Node(1);
root->left = new Node(2);
root->right = new Node(3);
root->left->left = new Node(4);
root->right->left = new Node(5);
root->right->right = new Node(6);
root->right->right->right = new Node(10);
root->right->right->left = new Node(7);
root->right->left->left = new Node(8);
root->right->left->right = new Node(9);
// A call to the function
printInternalNodes(root);
return 0;
} |
Java
// Java program to print all internal // nodes in tree import java.util.*;
class GfG
{ // A node in the Binary tree static class Node
{ int data;
Node left, right;
Node( int data)
{
left = right = null ;
this .data = data;
}
} // Function to print all internal nodes // in level order from left to right static void printInternalNodes(Node root)
{ // Using a queue for a level order traversal
Queue<Node> q = new LinkedList<Node>();
q.add(root);
while (!q.isEmpty())
{
// Check and pop the element in
// the front of the queue
Node curr = q.peek();
q.remove();
// The variable flag keeps track of
// whether a node is an internal node
boolean isInternal = false ;
// The node has a left child
if (curr.left != null )
{
isInternal = true ;
q.add(curr.left);
}
// The node has a right child
if (curr.right != null )
{
isInternal = true ;
q.add(curr.right);
}
// In case the node has either a left
// or right child or both print the data
if (isInternal == true )
System.out.print(curr.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.right.left = new Node( 5 );
root.right.right = new Node( 6 );
root.right.right.right = new Node( 10 );
root.right.right.left = new Node( 7 );
root.right.left.left = new Node( 8 );
root.right.left.right = new Node( 9 );
// A call to the function
printInternalNodes(root);
} } // This code is contributed by // Prerna Saini. |
Python3
# Python3 program to print all internal # nodes in tree # A node in the Binary tree class new_Node:
# Constructor to create a new_Node
def __init__( self , data):
self .data = data
self .left = None
self .right = None
# Function to print all internal nodes # in level order from left to right def printInternalNodes(root):
# Using a queue for a level order traversal
q = []
q.append(root)
while ( len (q)):
# Check and pop the element in
# the front of the queue
curr = q[ 0 ]
q.pop( 0 )
# The variable flag keeps track of
# whether a node is an internal node
isInternal = 0
# The node has a left child
if (curr.left):
isInternal = 1
q.append(curr.left)
# The node has a right child
if (curr.right):
isInternal = 1
q.append(curr.right)
# In case the node has either a left
# or right child or both print the data
if (isInternal):
print (curr.data, end = " " )
# Driver Code root = new_Node( 1 )
root.left = new_Node( 2 )
root.right = new_Node( 3 )
root.left.left = new_Node( 4 )
root.right.left = new_Node( 5 )
root.right.right = new_Node( 6 )
root.right.right.right = new_Node( 10 )
root.right.right.left = new_Node( 7 )
root.right.left.left = new_Node( 8 )
root.right.left.right = new_Node( 9 )
# A call to the function printInternalNodes(root) # This code is contributed by SHUBHAMSINGH10 |
C#
// C# program to print all internal // nodes in tree using System;
using System.Collections.Generic;
class GFG
{ // A node in the Binary tree public class Node
{ public int data;
public Node left, right;
public Node( int data)
{
left = right = null ;
this .data = data;
}
} // Function to print all internal nodes // in level order from left to right static void printInternalNodes(Node root)
{ // Using a queue for a level order traversal
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
while (q.Count != 0)
{
// Check and pop the element in
// the front of the queue
Node curr = q.Peek();
q.Dequeue();
// The variable flag keeps track of
// whether a node is an internal node
Boolean isInternal = false ;
// The node has a left child
if (curr.left != null )
{
isInternal = true ;
q.Enqueue(curr.left);
}
// The node has a right child
if (curr.right != null )
{
isInternal = true ;
q.Enqueue(curr.right);
}
// In case the node has either a left
// or right child or both print the data
if (isInternal == true )
Console.Write(curr.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.right.left = new Node(5);
root.right.right = new Node(6);
root.right.right.right = new Node(10);
root.right.right.left = new Node(7);
root.right.left.left = new Node(8);
root.right.left.right = new Node(9);
// A call to the function
printInternalNodes(root);
} } // This code contributed by Rajput-Ji |
Javascript
<script> // JavaScript program to print all internal nodes in tree
// A node in the Binary tree
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
// Function to print all internal nodes
// in level order from left to right
function printInternalNodes(root)
{
// Using a queue for a level order traversal
let q = [];
q.push(root);
while (q.length > 0)
{
// Check and pop the element in
// the front of the queue
let curr = q[0];
q.shift();
// The variable flag keeps track of
// whether a node is an internal node
let isInternal = false ;
// The node has a left child
if (curr.left != null )
{
isInternal = true ;
q.push(curr.left);
}
// The node has a right child
if (curr.right != null )
{
isInternal = true ;
q.push(curr.right);
}
// In case the node has either a left
// or right child or both print the data
if (isInternal == true )
document.write(curr.data + " " );
}
}
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.right.left = new Node(5);
root.right.right = new Node(6);
root.right.right.right = new Node(10);
root.right.right.left = new Node(7);
root.right.left.left = new Node(8);
root.right.left.right = new Node(9);
// A call to the function
printInternalNodes(root);
</script> |
Output:
1 2 3 5 6
Recommended Articles