Number of children of given node in n-ary Tree

• Difficulty Level : Medium
• Last Updated : 17 Jul, 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 ` `using` `namespace` `std; ` ` `  `// Represents a node of an n-ary tree ` `class` `Node { ` ` `  `public``: ` `    ``int` `key; ` `    ``vector 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 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 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 q = ``new` `LinkedList(); ` `    ``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#

 `// 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 child = ``new` `List(); ` ` `  `    ``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 q = ``new` `Queue(); ` `    ``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

 ``

Output:

`3`

Time Complexity : O(N), where N is the number of nodes in tree.
Auxiliary Space : O(N), where N is the number of nodes in tree.

My Personal Notes arrow_drop_up
Recommended Articles
Page :