Related Articles
Print all internal nodes of a Binary tree
• Difficulty Level : Medium
• Last Updated : 30 Oct, 2019

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 ``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 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 q = ``new` `LinkedList(); ``    ``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 q = ``new` `Queue(); ``    ``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`
Output:
```1 2 3 5 6
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up