Number of children of given node in n-ary Tree

Last Updated : 17 Aug, 2022

Given a node x, find the number of children of x(if it exists) in the given n-ary tree.

Example :

Input : x = 50
Output : 3
Explanation : 50 has 3 children having values 40, 100 and 20.

Approach :

Initialize the number of children as 0.
For every node in the n-ary tree, check if its value is equal to x or not. If yes, then return the number of children.
If the value of x is not equal to the current node then, push all the children of current node in the queue.
Keep Repeating the above step until the queue becomes empty.

Below is the implementation of the above idea :

C++

// C++ program to find number
// of children of given node
#include <bits/stdc++.h>
using namespace std;

// Represents a node of an n-ary tree
class Node {

public:
    int key;
    vector<Node*> child;

    Node(int data)
    {
        key = data;
    }
};

// Function to calculate number
// of children of given node
int numberOfChildren(Node* root, int x)
{
    // initialize the numChildren as 0
    int numChildren = 0;

    if (root == NULL)
        return 0;

    // Creating a queue and pushing the root
    queue<Node*> q;
    q.push(root);

    while (!q.empty()) {
        int n = q.size();

        // If this node has children
        while (n > 0) {

            // Dequeue an item from queue and
            // check if it is equal to x
            // If YES, then return number of children
            Node* p = q.front();
            q.pop();
            if (p->key == x) {
                numChildren = numChildren + p->child.size();
                return numChildren;
            }

            // Enqueue all children of the dequeued item
            for (int i = 0; i < p->child.size(); i++)
                q.push(p->child[i]);
            n--;
        }
    }
    return numChildren;
}

// Driver program
int main()
{
    // Creating a generic tree
    Node* root = new Node(20);
    (root->child).push_back(new Node(2));
    (root->child).push_back(new Node(34));
    (root->child).push_back(new Node(50));
    (root->child).push_back(new Node(60));
    (root->child).push_back(new Node(70));
    (root->child[0]->child).push_back(new Node(15));
    (root->child[0]->child).push_back(new Node(20));
    (root->child[1]->child).push_back(new Node(30));
    (root->child[2]->child).push_back(new Node(40));
    (root->child[2]->child).push_back(new Node(100));
    (root->child[2]->child).push_back(new Node(20));
    (root->child[0]->child[1]->child).push_back(new Node(25));
    (root->child[0]->child[1]->child).push_back(new Node(50));

    // Node whose number of
    // children is to be calculated
    int x = 50;

    // Function calling
    cout << numberOfChildren(root, x) << endl;

    return 0;
}

Java

// Java program to find number
// of children of given node
import java.util.*;

class GFG
{

// Represents a node of an n-ary tree
static class Node
{
    int key;
    Vector<Node> child = new Vector<>();

    Node(int data)
    {
        key = data;
    }
};

// Function to calculate number
// of children of given node
static int numberOfChildren(Node root, int x)
{
    // initialize the numChildren as 0
    int numChildren = 0;

    if (root == null)
        return 0;

    // Creating a queue and pushing the root
    Queue<Node> q = new LinkedList<Node>();
    q.add(root);

    while (!q.isEmpty())
    {
        int n = q.size();

        // If this node has children
        while (n > 0) 
        {

            // Dequeue an item from queue and
            // check if it is equal to x
            // If YES, then return number of children
            Node p = q.peek();
            q.remove();
            if (p.key == x) 
            {
                numChildren = numChildren +
                              p.child.size();
                return numChildren;
            }

            // Enqueue all children of the dequeued item
            for (int i = 0; i < p.child.size(); i++)
                q.add(p.child.get(i));
            n--;
        }
    }
    return numChildren;
}

// Driver Code
public static void main(String[] args) 
{
    
    // Creating a generic tree
    Node root = new Node(20);
    (root.child).add(new Node(2));
    (root.child).add(new Node(34));
    (root.child).add(new Node(50));
    (root.child).add(new Node(60));
    (root.child).add(new Node(70));
    (root.child.get(0).child).add(new Node(15));
    (root.child.get(0).child).add(new Node(20));
    (root.child.get(1).child).add(new Node(30));
    (root.child.get(2).child).add(new Node(40));
    (root.child.get(2).child).add(new Node(100));
    (root.child.get(2).child).add(new Node(20));
    (root.child.get(0).child.get(1).child).add(new Node(25));
    (root.child.get(0).child.get(1).child).add(new Node(50));

    // Node whose number of
    // children is to be calculated
    int x = 50;

    // Function calling
    System.out.println(numberOfChildren(root, x));
}
}

// This code is contributed by 29AjayKumar

Python3

# Python3 program to find number
# of children of given node

# Node of a linked list 
class Node: 
    def __init__(self, data = None): 
        self.key = data 
        self.child = []

# Function to calculate number
# of children of given node
def numberOfChildren( root, x):

    # initialize the numChildren as 0
    numChildren = 0

    if (root == None):
        return 0

    # Creating a queue and appending the root
    q = []
    q.append(root)

    while (len(q) > 0) :
        n = len(q)

        # If this node has children
        while (n > 0): 

            # Dequeue an item from queue and
            # check if it is equal to x
            # If YES, then return number of children
            p = q[0]
            q.pop(0)
            if (p.key == x) :
                numChildren = numChildren + len(p.child)
                return numChildren
            
            i = 0
            
            # Enqueue all children of the dequeued item
            while ( i < len(p.child)):
                q.append(p.child[i])
                i = i + 1
            n = n - 1

    return numChildren

# Driver program

# Creating a generic tree
root = Node(20)
(root.child).append(Node(2))
(root.child).append(Node(34))
(root.child).append(Node(50))
(root.child).append(Node(60))
(root.child).append(Node(70))
(root.child[0].child).append(Node(15))
(root.child[0].child).append(Node(20))
(root.child[1].child).append(Node(30))
(root.child[2].child).append(Node(40))
(root.child[2].child).append(Node(100))
(root.child[2].child).append(Node(20))
(root.child[0].child[1].child).append(Node(25))
(root.child[0].child[1].child).append(Node(50))

# Node whose number of
# children is to be calculated
x = 50

# Function calling
print( numberOfChildren(root, x) )

# This code is contributed by Arnab Kundu

// C# program to find number
// of children of given node
using System;
using System.Collections.Generic;
    
class GFG
{

// Represents a node of an n-ary tree
public class Node
{
    public int key;
    public List<Node> child = new List<Node>();

    public Node(int data)
    {
        key = data;
    }
};

// Function to calculate number
// of children of given node
static int numberOfChildren(Node root, int x)
{
    // initialize the numChildren as 0
    int numChildren = 0;

    if (root == null)
        return 0;

    // Creating a queue and pushing the root
    Queue<Node> q = new Queue<Node>();
    q.Enqueue(root);

    while (q.Count != 0)
    {
        int n = q.Count;

        // If this node has children
        while (n > 0) 
        {

            // Dequeue an item from queue and
            // check if it is equal to x
            // If YES, then return number of children
            Node p = q.Peek();
            q.Dequeue();
            if (p.key == x) 
            {
                numChildren = numChildren +
                              p.child.Count;
                return numChildren;
            }

            // Enqueue all children of the dequeued item
            for (int i = 0; i < p.child.Count; i++)
                q.Enqueue(p.child[i]);
            n--;
        }
    }
    return numChildren;
}

// Driver Code
public static void Main(String[] args) 
{
    
    // Creating a generic tree
    Node root = new Node(20);
    (root.child).Add(new Node(2));
    (root.child).Add(new Node(34));
    (root.child).Add(new Node(50));
    (root.child).Add(new Node(60));
    (root.child).Add(new Node(70));
    (root.child[0].child).Add(new Node(15));
    (root.child[0].child).Add(new Node(20));
    (root.child[1].child).Add(new Node(30));
    (root.child[2].child).Add(new Node(40));
    (root.child[2].child).Add(new Node(100));
    (root.child[2].child).Add(new Node(20));
    (root.child[0].child[1].child).Add(new Node(25));
    (root.child[0].child[1].child).Add(new Node(50));

    // Node whose number of
    // children is to be calculated
    int x = 50;

    // Function calling
    Console.WriteLine(numberOfChildren(root, x));
}
}

// This code is contributed by 29AjayKumar

JavaScript

<script>

// javascript program to find number
// of children of given node

// Represents a node of an n-ary tree
class Node
{
    constructor(data)
    {
        this.key = data;
        this.child = []
    }
};

// Function to calculate number
// of children of given node
function numberOfChildren(root, x)
{
    // initialize the numChildren as 0
    var numChildren = 0;

    if (root == null)
        return 0;

    // Creating a queue and pushing the root
    var q = [];
    q.push(root);

    while (q.length != 0)
    {
        var n = q.length;

        // If this node has children
        while (n > 0) 
        {

            // Dequeue an item from queue and
            // check if it is equal to x
            // If YES, then return number of children
            var p = q[0];
            q.shift();
            if (p.key == x) 
            {
                numChildren = numChildren +
                              p.child.length;
                return numChildren;
            }

            // push all children of the dequeued item
            for (var i = 0; i < p.child.length; i++)
                q.push(p.child[i]);
            n--;
        }
    }
    return numChildren;
}

// Driver Code
// Creating a generic tree
var root = new Node(20);
(root.child).push(new Node(2));
(root.child).push(new Node(34));
(root.child).push(new Node(50));
(root.child).push(new Node(60));
(root.child).push(new Node(70));
(root.child[0].child).push(new Node(15));
(root.child[0].child).push(new Node(20));
(root.child[1].child).push(new Node(30));
(root.child[2].child).push(new Node(40));
(root.child[2].child).push(new Node(100));
(root.child[2].child).push(new Node(20));
(root.child[0].child[1].child).push(new Node(25));
(root.child[0].child[1].child).push(new Node(50));

// Node whose number of
// children is to be calculated
var x = 50;

// Function calling
document.write(numberOfChildren(root, x));

// This code is contributed by itsok.
</script>