Print all internal nodes of a Binary tree

Last Updated : 28 Jun, 2021

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:
1. The node has a left child only.
2. The node has a right child only.
3. The node has both left and right child.
4. 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# 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

Analysis of Algorithms

code_freak

Improve

Article Tags :

Print all internal nodes of a Binary tree

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?