Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Print the nodes having exactly one child in a Binary tree

  • Difficulty Level : Medium
  • Last Updated : 16 Jun, 2021

Given a binary tree, the task is to print all the nodes having exactly one child. Print “-1” if no such node exists.
Examples: 

Input: 
            2
           / \
          3   5
         /   / \
        7   8   6
Output: 3
Explanation:
There is only one node having
single child that is 3.

Input:
           9
          / \
         7   8
            / \
           4   3
Output: -1
Explanation:
There is no node having exactly one
child in the binary tree.

Approach: The idea is to traverse the tree in the inorder traversal and at each step of the traversal check that if the node is having exactly one child. Then append that node into a result array to keep track of such nodes. After the traversal, simply print each element of this result array.

Below is the implementation of the above approach: 

C++




// C++ implementation to print
// the nodes having a single child
#include <bits/stdc++.h>
using namespace std;
 
// Class of the Binary Tree node
struct Node
{
  int data;
  Node *left, *right;
 
  Node(int x)
  {
    data = x;
    left = right = NULL;
  }
};
 
vector<int> lst;
 
// Function to find the nodes
// having single child
void printNodesOneChild(Node* root)
{
  // Base case
  if (root == NULL)
    return;
 
  // Condition to check if the
  // node is having only one child
  if (root->left != NULL &&
      root->right == NULL ||
      root->left == NULL &&
      root->right != NULL)
  {
    lst.push_back(root->data);
  }
 
  // Traversing the left child
  printNodesOneChild(root -> left);
 
  // Traversing the right child
  printNodesOneChild(root -> right);
}
 
//Driver code
int main()
{
  // Constructing the binary tree
  Node *root = new Node(2);
  root -> left = new Node(3);
  root -> right = new Node(5);
  root -> left -> left = new Node(7);
  root -> right -> left = new Node(8);
  root -> right -> right = new Node(6);
 
  // Function calling
  printNodesOneChild(root);
 
  // Condition to check if there is
  // no such node having single child
  if (lst.size() == 0)
    printf("-1");
  else
  {
    for(int value : lst)
    {
      cout << (value) << endl;
    }
  }
}
 
// This code is contributed by Mohit Kumar 29
Java



// Java implementation to print
// the nodes having a single child
import java.util.Vector;
 
// Class of the Binary Tree node
class Node
{
    int data;
    Node left, right;
 
    Node(int data)
    {
        this.data = data;
    }
}
 
class GFG{
 
// List to keep track of nodes
// having single child
static Vector<Integer> list = new Vector<>();
 
// Function to find the nodes 
// having single child 
static void printNodesOneChild(Node root)
{
    // Base case
    if (root == null)
        return;
 
    // Condition to check if the node
    // is having only one child
    if (root.left != null && root.right == null ||
        root.left == null && root.right != null)
    {
        list.add(root.data);
    }
     
    // Traversing the left child
    printNodesOneChild(root.left);
     
    // Traversing the right child
    printNodesOneChild(root.right);
}
 
// Driver code
public static void main(String[] args)
{
     
    // Constructing the binary tree
    Node root = new Node(2);
    root.left = new Node(3);
    root.right = new Node(5);
    root.left.left = new Node(7);
    root.right.left = new Node(8);
    root.right.right = new Node(6);
 
    // Function calling
    printNodesOneChild(root);
 
    // Condition to check if there is
    // no such node having single child
    if (list.size() == 0)
        System.out.println(-1);
    else
    {
        for(int value : list)
        {
            System.out.println(value);
        }
    }
}
}
 
// This code is contributed by sumit_9
Python3



# Python3 implementation to print
# the nodes having a single child
 
# Class of the Binary Tree node
class node:
     
    # Constructor to construct
    # the node of the Binary tree
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None
         
# List to keep track of
# nodes having single child
single_child_nodes = []
 
# Function to find the nodes
# having single child
def printNodesOneChild(root):
     
    # Base Case
    if not root:
        return
     
    # Condition to check if the node
    # is having only one child
    if not root.left and root.right:
        single_child_nodes.append(root)
    elif root.left and not root.right:
        single_child_nodes.append(root)
         
    # Traversing the left child
    printNodesOneChild(root.left)
     
    # Traversing the right child
    printNodesOneChild(root.right)
    return
 
# Driver Code
if __name__ == "__main__":
     
    # Condtruction of Binary Tree
    root = node(2)
    root.left = node(3)
    root.right = node(5)
    root.left.left = node(7)
    root.right.left = node(8)
    root.right.right = node(6)
     
    # Function Call
    printNodesOneChild(root)
     
    # Condition to check if there is
    # no such node having single child
    if not len(single_child_nodes):
        print(-1)
    else:
        for i in single_child_nodes:
            print(i.val, end = " ")
        print()
C#



// C# implementation to print
// the nodes having a single child
using System;
using System.Collections;
 
class GFG{
     
// Structure of binary tree
public class Node 
{
    public Node left;
    public Node right;
    public int data;
};
 
// Function to create a new node
static Node newNode(int key)
{
    Node node = new Node();
    node.left = node.right = null;
    node.data = key;
    return node;
}
 
// List to keep track of nodes
// having single child
static ArrayList list = new ArrayList();
  
// Function to find the nodes 
// having single child 
static void printNodesOneChild(Node root)
{
     
    // Base case
    if (root == null)
        return;
         
    // Condition to check if the node
    // is having only one child
    if (root.left != null && root.right == null ||
        root.left == null && root.right != null)
    {
        list.Add(root.data);
    }
      
    // Traversing the left child
    printNodesOneChild(root.left);
      
    // Traversing the right child
    printNodesOneChild(root.right);
}
 
// Driver code
static public void Main()
{
     
    // Constructing the binary tree
    Node root = newNode(2);
    root.left = newNode(3);
    root.right = newNode(5);
    root.left.left = newNode(7);
    root.right.left = newNode(8);
    root.right.right = newNode(6);
     
    // Function calling
    printNodesOneChild(root);
     
    // Condition to check if there is
    // no such node having single child
    if (list.Count == 0)
        Console.WriteLine(-1);
    else
    {
        foreach(int value in list)
        {
            Console.WriteLine(value);
        }
    }
}
}
 
// This code is contributed by offbeat
Javascript



<script>
// Javascript implementation to print
// the nodes having a single child
 
// Class of the Binary Tree node
class Node
{
    constructor(data)
    {
        this.data = data;
        this.left=this.right=null;
    }
     
}
 
// List to keep track of nodes
// having single child
let list = [];
 
// Function to find the nodes
// having single child
function printNodesOneChild(root)
{
    // Base case
    if (root == null)
        return;
  
    // Condition to check if the node
    // is having only one child
    if (root.left != null && root.right == null ||
        root.left == null && root.right != null)
    {
        list.push(root.data);
    }
      
    // Traversing the left child
    printNodesOneChild(root.left);
      
    // Traversing the right child
    printNodesOneChild(root.right);
}
 
// Driver code
// Constructing the binary tree
    let root = new Node(2);
    root.left = new Node(3);
    root.right = new Node(5);
    root.left.left = new Node(7);
    root.right.left = new Node(8);
    root.right.right = new Node(6);
  
    // Function calling
    printNodesOneChild(root);
  
    // Condition to check if there is
    // no such node having single child
    if (list.length == 0)
        document.write(-1);
    else
    {
        document.write(list.join("<br>"))
    }
 
// This code is contributed by patel2127
</script>
Output
3

My Personal Notes
arrow_drop_up
Previous
Sum of all elements in an array between zeros
Next

Find the total count of numbers up to N digits in a given base B
Recommended Articles
Page :
Sum of nodes in a binary tree having only the left child nodes
09, Nov 21
Count root to leaf paths having exactly K distinct nodes in a Binary Tree
16, Oct 20
Sum of all the child nodes with even parent values in a Binary Tree
15, Jan 20
Sum of all the child nodes with even grandparents in a Binary Tree
16, May 20
Count of nodes in a Binary Tree whose child is its prime factors
09, Apr 20
Sum of all the parent nodes having child node x
25, Sep 17
Count of nodes in a binary tree having their nodes in range [L, R]
22, Dec 21
Print leaf nodes in binary tree from left to right using one stack
11, Mar 19
Print the nodes of Binary Tree having a grandchild
06, Jul 20
Print all nodes in a binary tree having K leaves
22, Dec 16
Count all Grandparent-Parent-Child Triplets in a binary tree whose sum is greater than X
18, Dec 18
Sum of all parent-child differences in a Binary Tree
29, Apr 19
Count of nodes in a given N-ary tree having distance to all leaf nodes equal in their subtree
26, Nov 21
Count the nodes of the tree which make a pangram when concatenated with the sub-tree nodes
28, May 19
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
19, Jan 18
Check if all the Nodes in a Binary Tree having common values are at least D distance apart
11, Aug 20
Count nodes having highest value in the path from root to itself in a Binary Tree
12, Oct 20
Count nodes having smallest value in the path from root to itself in a Binary Tree
19, Oct 20
Given a binary tree, print out all of its root-to-leaf paths one per line.
09, Aug 09
Print all full nodes in a Binary Tree
02, Apr 17
Print all internal nodes of a Binary tree
11, Feb 19
Print odd positioned nodes of odd levels in level order of the given binary tree
05, Sep 19
Print Levels of all nodes in a Binary Tree
15, Aug 17
Print all leaf nodes of a Binary Tree from left to right
30, Sep 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
shivanshu_gupta
@shivanshu_gupta
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!