Open In App

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

Count nodes with two children at level L in a Binary Tree

Given a Binary tree, the task is to count the number of nodes with two children at a given level L.

Examples: 



Input: 
          1
         /  \
        2    3
       / \    \
      4   5    6
         /    / \
        7    8   9
L = 2
Output: 1

Input:
          20
         /   \
        8     22
       / \    / \
      5   3  4   25
     / \  / \     \
    1  10 2  14    6
L = 3
Output: 2

Approach: Initialize a variable count = 0. Recursively traverse the tree in a level order manner. If the current level is same as the given level, then check whether the current node has two children. If it has two children then increment the variable count.

Below is the implementation of the above approach: 






// C++ program to find number of full nodes
// at a given level
#include <bits/stdc++.h>
using namespace std;
 
// A binary tree node
struct Node {
    int data;
    struct Node *left, *right;
};
 
// Utility function to allocate memory for a new node
struct Node* newNode(int data)
{
    struct Node* node = new (struct Node);
    node->data = data;
    node->left = node->right = NULL;
    return (node);
}
 
// Function that returns the height of binary tree
int height(struct Node* root)
{
    if (root == NULL)
        return 0;
 
    int lheight = height(root->left);
    int rheight = height(root->right);
 
    return max(lheight, rheight) + 1;
}
 
// Level Order traversal to find the number of nodes
// having two children
void LevelOrder(struct Node* root, int level, int& count)
{
    if (root == NULL)
        return;
 
    if (level == 1 && root->left && root->right)
        count++;
 
    else if (level > 1) {
        LevelOrder(root->left, level - 1, count);
        LevelOrder(root->right, level - 1, count);
    }
}
 
// Returns the number of full nodes
// at a given level
int CountFullNodes(struct Node* root, int L)
{
    // Stores height of tree
    int h = height(root);
 
    // Stores count of nodes at a given level
    // that have two children
    int count = 0;
 
    LevelOrder(root, L, count);
 
    return count;
}
 
// Driver code
int main()
{
    struct Node* root = newNode(7);
    root->left = newNode(5);
    root->right = newNode(6);
    root->left->left = newNode(8);
    root->left->right = newNode(1);
    root->left->left->left = newNode(2);
    root->left->left->right = newNode(11);
    root->right->left = newNode(3);
    root->right->right = newNode(9);
    root->right->right->right = newNode(13);
    root->right->right->left = newNode(10);
    root->right->right->right->left = newNode(4);
    root->right->right->right->right = newNode(12);
 
    int L = 3;
 
    cout << CountFullNodes(root, L);
 
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java program to find number of full nodes 


// at a given level 



class GFG



{


 


//INT class



static class INT



{



    int a;



}


 


// A binary tree node 



static class Node 



{ 



    int data; 




    Node left, right; 



}; 


 


// Utility function to allocate memory for a new node 



static Node newNode(int data) 



{ 



    Node node = new Node(); 




    node.data = data; 




    node.left = node.right = null; 




    return (node); 



} 


 


// Function that returns the height of binary tree 



static int height(Node root) 



{ 



    if (root == null) 




        return 0; 



 



    int lheight = height(root.left); 




    int rheight = height(root.right); 



 



    return Math.max(lheight, rheight) + 1; 



} 


 


// Level Order traversal to find the number of nodes 


// having two children 



static void LevelOrder( Node root, int level, INT count) 



{ 



    if (root == null) 




        return; 



 



    if (level == 1 && root.left!=null && root.right!=null) 




        count.a++; 



 



    else if (level > 1)




    { 




        LevelOrder(root.left, level - 1, count); 




        LevelOrder(root.right, level - 1, count); 




    } 



} 


 


// Returns the number of full nodes 


// at a given level 



static int CountFullNodes( Node root, int L) 



{ 



    // Stores height of tree 




    int h = height(root); 



 



    // Stores count of nodes at a given level 




    // that have two children 




    INT count =new INT();




    count.a = 0; 



 



    LevelOrder(root, L, count); 



 



    return count.a; 



} 


 


// Driver code 



public static void main(String args[])



{ 



    Node root = newNode(7); 




    root.left = newNode(5); 




    root.right = newNode(6); 




    root.left.left = newNode(8); 




    root.left.right = newNode(1); 




    root.left.left.left = newNode(2); 




    root.left.left.right = newNode(11); 




    root.right.left = newNode(3); 




    root.right.right = newNode(9); 




    root.right.right.right = newNode(13); 




    root.right.right.left = newNode(10); 




    root.right.right.right.left = newNode(4); 




    root.right.right.right.right = newNode(12); 



 



    int L = 3; 



 



    System.out.print( CountFullNodes(root, L)); 



 


} 


}


 


// This code is contributed by Arnab Kundu


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python3 program to find number of 


# full nodes at a given level


 


# INT class



class INT:




  



    def __init__(self):




         



        self.a = 0



 


# A binary tree node



class Node:




     



    def __init__(self, data):




         



        self.left = None




        self.right = None




        self.data = data




  


# Utility function to allocate 


# memory for a new node



def newNode(data):



 



    node = Node(data)




     



    return node



 


# Function that returns the


# height of binary tree



def height(root):



 



    if (root == None):




        return 0;




  



    lheight = height(root.left);




    rheight = height(root.right);




  



    return max(lheight, rheight) + 1;



 


# Level Order traversal to find the


# number of nodes having two children



def LevelOrder(root, level, count):



 



    if (root == None):




        return;




  



    if (level == 1 and




        root.left != None and




       root.right != None):




        count.a += 1




  



    elif (level > 1):




        LevelOrder(root.left, 




                   level - 1, count);




        LevelOrder(root.right, 




                   level - 1, count);




  


# Returns the number of full nodes


# at a given level



def CountFullNodes(root, L):



 



    # Stores height of tree




    h = height(root);




  



    # Stores count of nodes at a 




    # given level that have two children




    count = INT()




  



    LevelOrder(root, L, count);




  



    return count.a



 


# Driver code    



if __name__=="__main__":




     



    root = newNode(7);




    root.left = newNode(5);




    root.right = newNode(6);




    root.left.left = newNode(8);




    root.left.right = newNode(1);




    root.left.left.left = newNode(2);




    root.left.left.right = newNode(11);




    root.right.left = newNode(3);




    root.right.right = newNode(9);




    root.right.right.right = newNode(13);




    root.right.right.left = newNode(10);




    root.right.right.right.left = newNode(4);




    root.right.right.right.right = newNode(12);




  



    L = 3;




  



    print(CountFullNodes(root, L))




     


# This code is contributed by rutvik_56


















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# program to find number of full nodes 


// at a given level



using System;



 



class GFG 



{ 


 


// INT class 



public class INT 



{ 



    public int a; 



} 


 


// A binary tree node 



public class Node 



{ 



    public int data; 




    public Node left, right; 



}; 


 


// Utility function to allocate memory for a new node 



static Node newNode(int data) 



{ 



    Node node = new Node(); 




    node.data = data; 




    node.left = node.right = null; 




    return (node); 



} 


 


// Function that returns the height of binary tree 



static int height(Node root) 



{ 



    if (root == null) 




        return 0; 



 



    int lheight = height(root.left); 




    int rheight = height(root.right); 



 



    return Math.Max(lheight, rheight) + 1; 



} 


 


// Level Order traversal to find the number of nodes 


// having two children 



static void LevelOrder( Node root, int level, INT count) 



{ 



    if (root == null) 




        return; 



 



    if (level == 1 && root.left!=null && root.right!=null) 




        count.a++; 



 



    else if (level > 1) 




    { 




        LevelOrder(root.left, level - 1, count); 




        LevelOrder(root.right, level - 1, count); 




    } 



} 


 


// Returns the number of full nodes 


// at a given level 



static int CountFullNodes( Node root, int L) 



{ 



    // Stores height of tree 




    int h = height(root); 



 



    // Stores count of nodes at a given level 




    // that have two children 




    INT count =new INT(); 




    count.a = 0; 



 



    LevelOrder(root, L, count); 



 



    return count.a; 



} 


 


// Driver code 



public static void Main(String []args) 



{ 



    Node root = newNode(7); 




    root.left = newNode(5); 




    root.right = newNode(6); 




    root.left.left = newNode(8); 




    root.left.right = newNode(1); 




    root.left.left.left = newNode(2); 




    root.left.left.right = newNode(11); 




    root.right.left = newNode(3); 




    root.right.right = newNode(9); 




    root.right.right.right = newNode(13); 




    root.right.right.left = newNode(10); 




    root.right.right.right.left = newNode(4); 




    root.right.right.right.right = newNode(12); 



 



    int L = 3; 



 



    Console.Write( CountFullNodes(root, L)); 



 


} 


} 


 


// This code is contributed by 29AjayKumar


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>


 


// Javascript program to find number


// of full nodes at a given level


 


// INT class


let a = 0;


 


// A binary tree node


class Node


{



    constructor(data) 




    {




        this.left = null;




        this.right = null;




        this.data = data;




    }



}


 


// Utility function to allocate memory


// for a new node



function newNode(data)



{



    let node = new Node(data);




    return (node);



}


 


// Function that returns the height


// of binary tree



function height(root)



{



    if (root == null)




        return 0;



 



    let lheight = height(root.left);




    let rheight = height(root.right);



 



    return Math.max(lheight, rheight) + 1;



}


 


// Level Order traversal to find the number 


// of nodes having two children



function LevelOrder(root, level)



{



    if (root == null)




        return;



 



    if (level == 1 && root.left != null && 




                     root.right != null)




        a++;



 



    else if (level > 1)




    {




        LevelOrder(root.left, level - 1);




        LevelOrder(root.right, level - 1);




    }



}


 


// Returns the number of full nodes


// at a given level



function CountFullNodes(root, L)



{



     



    // Stores height of tree




    let h = height(root);



 



    LevelOrder(root, L);



 



    return a;



}


 


// Driver code


let root = newNode(7);


root.left = newNode(5);


root.right = newNode(6);


root.left.left = newNode(8);


root.left.right = newNode(1);


root.left.left.left = newNode(2);


root.left.left.right = newNode(11);


root.right.left = newNode(3);


root.right.right = newNode(9);


root.right.right.right = newNode(13);


root.right.right.left = newNode(10);


root.right.right.right.left = newNode(4);


root.right.right.right.right = newNode(12);


 


let L = 3;


 


document.write(CountFullNodes(root, L));


 


// This code is contributed by mukesh07


 


</script>


















                        






                        








Output: 

2


 


Time Complexity: O(N) 
Auxiliary Space: O(N)
Another Approach:
We can solve this problem by level order traversal using queue. In which we find the element which have two children at given level and increment the count variable. 
Below is the implementation of above approach:














                                    



                                    




                                    




                                    


                                



















// C++ program to find number of full nodes


// at a given level


#include <bits/stdc++.h>



using namespace std;



 


// A binary tree node



struct Node {




    int data;




    struct Node* left;




    struct Node* right;



};


 


// function to allocate memory for a new node



struct Node* newNode(int data)



{



    struct Node* node = new Node();




    node->data = data;




    node->left = node->right = NULL;




    return node;



}


 


// function to return the number


// of nodes



int levelOrderTraversal(Node* root, int L)



{



    int count = 0;




    int level = 0;




    queue<Node*> q;




    q.push(root);




    while (!q.empty()) {




        level++;




        int n = q.size();




        for (int i = 0; i < n; i++) {




            Node* front_node = q.front();




            q.pop();




            if (L == level && front_node->left != NULL




                && front_node->right != NULL) {




                count++;




            }




            if (front_node->left != NULL)




                q.push(front_node->left);




            if (front_node->right != NULL)




                q.push(front_node->right);




        }




    }




    return count;



}


 


// Driver Code



int main()



{



    Node* root = newNode(7);




    root->left = newNode(5);




    root->right = newNode(6);




    root->left->left = newNode(8);




    root->left->right = newNode(1);




    root->left->left->left = newNode(2);




    root->left->left->right = newNode(11);




    root->right->left = newNode(3);




    root->right->right = newNode(9);




    root->right->right->right = newNode(13);




    root->right->right->left = newNode(10);




    root->right->right->right->left = newNode(4);




    root->right->right->right->right = newNode(12);



 



    int L = 3;




    cout << levelOrderTraversal(root, L) << endl;




    return 0;



}


// This code is contributed by Kirti Agarwal


















                        






                        























                                    



                                    




                                    




                                    


                                



















// Java program to find number of full nodes


// at a given level



import java.util.LinkedList;




import java.util.Queue;



 


// A binary tree node



class Node {




    int data;




    Node left;




    Node right;




     



    // constructor to initialize data and left and right pointers




    Node(int data) {




        this.data = data;




        this.left = null;




        this.right = null;




    }



}


 



public class Main {




    // function to return the number of full nodes




    static int levelOrderTraversal(Node root, int L) {




        int count = 0;




        int level = 0;




        Queue<Node> q = new LinkedList<Node>();




        q.add(root);




        while (!q.isEmpty()) {




            level++;




            int n = q.size();




            for (int i = 0; i < n; i++) {




                Node front_node = q.poll();




                if (L == level && front_node.left != null




                    && front_node.right != null) {




                    count++;




                }




                if (front_node.left != null)




                    q.add(front_node.left);




                if (front_node.right != null)




                    q.add(front_node.right);




            }




        }




        return count;




    }




     



    // Driver Code




    public static void main(String[] args) {




        Node root = new Node(7);




        root.left = new Node(5);




        root.right = new Node(6);




        root.left.left = new Node(8);




        root.left.right = new Node(1);




        root.left.left.left = new Node(2);




        root.left.left.right = new Node(11);




        root.right.left = new Node(3);




        root.right.right = new Node(9);




        root.right.right.right = new Node(13);




        root.right.right.left = new Node(10);




        root.right.right.right.left = new Node(4);




        root.right.right.right.right = new Node(12);



 



        int L = 3;




        System.out.println(levelOrderTraversal(root, L));




    }



}


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python3 program to find number of


# full nodes at a given level


 


# a binary tree node



class Node:




    def __init__(self, data):




        self.data = data




        self.left = None




        self.right = None




         


# function to allocate memory for a new node



def newNode(data):




    return Node(data)



 


# function to return the number


# of nodes



def levelOrderTraversal(root, L):




    count = 0




    level = 0




    q = []




    q.append(root)




    while(len(q) > 0):




        level += 1




        n = len(q)




        for i in range(n):




            front_node = q.pop(0)




            if(L == level and front_node.left is not None and front_node.right is not None):




                count += 1




            if(front_node.left is not  None):




                q.append(front_node.left)




            if(front_node.right is not None):




                q.append(front_node.right)




         



    return count;



 


#driver code to test above functions



root = newNode(7);




root.left = newNode(5);




root.right = newNode(6);




root.left.left = newNode(8);




root.left.right = newNode(1);




root.left.left.left = newNode(2);




root.left.left.right = newNode(11);




root.right.left = newNode(3);




root.right.right = newNode(9);




root.right.right.right = newNode(13);




root.right.right.left = newNode(10);




root.right.right.right.left = newNode(4);




root.right.right.right.right = newNode(12);



 



L = 3;



 



print(levelOrderTraversal(root, L))



















                        






                        























                                    



                                    




                                    




                                    


                                



















// JavaScript program to find number of full nodes


// at a given level


// a binary tree node


class Node{



    constructor(data){




        this.data = data;




        this.left = this.right = null;




    }



}


 


// function to allcated memory for a new node



function newNode(data){




    return new Node(data);



}


 


// function to return the number


// of nodes



function levelOrderTraversal(root, L){




    let count = 0;




    let level = 0;




    let q = [];




    q.push(root);




    while(q.length > 0){




        level++;




        let n = q.length;




        for(let i = 0; i<n; i++){




            let front_node = q.shift();




            if(L == level && front_node.left != null




            && front_node.right != null){




                count++;




            }




            if(front_node.left) q.push(front_node.left);




            if(front_node.right) q.push(front_node.right);




        }




    }




    return count;



}


 


// driver code


let root = newNode(7);


root.left = newNode(5);


root.right = newNode(6);


root.left.left = newNode(8);


root.left.right = newNode(1);


root.left.left.left = newNode(2);


root.left.left.right = newNode(11);


root.right.left = newNode(3);


root.right.right = newNode(9);


root.right.right.right = newNode(13);


root.right.right.left = newNode(10);


root.right.right.right.left = newNode(4);


root.right.right.right.right = newNode(12);


 


let L = 3;


console.log(levelOrderTraversal(root, L));


 


// THIS CODE IS CONTRIBUTED BY YASH AGARWAL(YASHAGARWAL2852002)


















                        






                        























                                    



                                    




                                    




                                    


                                




















using System;




using System.Collections.Generic;



 


// C# program to find number of full nodes


// at a given level



public class Node {




    public int data;




    public Node left, right;



 



    public Node(int data) {




        this.data = data;




        this.left = this.right = null;




    }



}


 



public class BinaryTree {




    public static int LevelOrderTraversal(Node root, int L) {




        int count = 0, level = 0;




        Queue<Node> q = new Queue<Node>();




        q.Enqueue(root);




        while (q.Count > 0) {




            level++;




            int n = q.Count;




            for (int i = 0; i < n; i++) {




                Node front_node = q.Dequeue();




                if (L == level && front_node.left != null && front_node.right != null) {




                    count++;




                }




                if (front_node.left != null) q.Enqueue(front_node.left);




                if (front_node.right != null) q.Enqueue(front_node.right);




            }




        }




        return count;




    }



 



    public static void Main() {




        Node root = new Node(7);




        root.left = new Node(5);




        root.right = new Node(6);




        root.left.left = new Node(8);




        root.left.right = new Node(1);




        root.left.left.left = new Node(2);




        root.left.left.right = new Node(11);




        root.right.left = new Node(3);




        root.right.right = new Node(9);




        root.right.right.right = new Node(13);




        root.right.right.left = new Node(10);




        root.right.right.right.left = new Node(4);




        root.right.right.right.right = new Node(12);



 



        int L = 3;




        Console.WriteLine(LevelOrderTraversal(root, L));




    }



}


















                        






                        








Output

2


Time Complexity: O(N) 
Auxiliary Space: O(N)

	

        Article Tags : 
        

            Data Structures
DSA
Tree        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Count nodes from all lower levels smaller than minimum valued node of current level for every level in a Binary Tree

          
2. Print the nodes corresponding to the level value for each level of a Binary Tree

          
3. Print nodes of a Binary Search Tree in Top Level Order and Reversed Bottom Level Order alternately

          
4. Modify a Binary Tree by adding a level of nodes with given value at a specified level

          
5. Difference between sums of odd level and even level nodes of a Binary Tree

          
6. Minimize changes to convert into Tree with root 1, even left children and odd right children

          
7. Count of nodes in a Binary tree with immediate children as its factors

          
8. Count of nodes in a Binary Tree whose immediate children are co-prime

          
9. Create Binary Tree with Nodes as Cumulative sum of children

          
10. Difference between sums of odd level and even level nodes in an N-ary Tree

          
11. Calculate sum of all nodes present in a level for each level of a Tree

          
12. Given a n-ary tree, count number of nodes which have more number of children than parents

          
13. Print nodes between two given level numbers of a binary tree

          
14. General Tree (Each node can have arbitrary number of children) Level Order Traversal

          
15. Convert an arbitrary Binary Tree to a tree that holds Children Sum Property - Set 2

          
16. Convert an arbitrary Binary Tree to a tree that holds Children Sum Property

          
17. Minimum value to be added at each level in Binary Tree to make all level sum equal

          
18. Difference between odd level and even level leaf sum in given Binary Tree

          
19. Check if max sum level of Binary tree divides tree into two equal sum halves

          
20. Count the nodes of the tree which make a pangram when concatenated with the sub-tree nodes

          
21. Print List of nodes of given n-ary Tree with number of children in range [0, n]

          
22. Count of nodes in a binary tree having their nodes in range [L, R]

          
23. Connect Nodes at same Level (Level Order Traversal)

          
24. Print odd positioned nodes of odd levels in level order of the given binary tree

          
25. Recursive Program to Print extreme nodes of each level of Binary Tree in alternate order