# Number of siblings of a given Node in n-ary Tree

Given an N-ary tree, find the number of siblings of given node x. Assume that x exists in the given n-ary tree.

Example :

```Input : 30
Output : 3
```

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

Approach : For every node in the given n-ary tree, push the children of the current node in the queue. While adding the children of current node in queue, check if any children is equal to the given value x or not. If yes, then return the number of siblings of x.

Below is the implementation of the above idea :

## C++

 `// C++ program to find number ` `// of siblings of a 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 siblings of a given node ` `int` `numberOfSiblings(Node* root, ``int` `x) ` `{ ` `    ``if` `(root == NULL) ` `        ``return` `0; ` ` `  `    ``// Creating a queue and ` `    ``// pushing the root ` `    ``queue q; ` `    ``q.push(root); ` ` `  `    ``while` `(!q.empty()) { ` `        ``// 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(); ` ` `  `        ``// Enqueue all children of ` `        ``// the dequeued item ` `        ``for` `(``int` `i = 0; i < p->child.size(); i++) { ` `            ``// If the value of children ` `            ``// is equal to x, then return ` `            ``// the number of siblings ` `            ``if` `(p->child[i]->key == x) ` `                ``return` `p->child.size() - 1; ` `            ``q.push(p->child[i]); ` `        ``} ` `    ``} ` `} ` ` `  `// Driver program ` `int` `main() ` `{ ` `    ``// Creating a generic tree as shown in above figure ` `    ``Node* root = ``new` `Node(50); ` `    ``(root->child).push_back(``new` `Node(2)); ` `    ``(root->child).push_back(``new` `Node(30)); ` `    ``(root->child).push_back(``new` `Node(14)); ` `    ``(root->child).push_back(``new` `Node(60)); ` `    ``(root->child[0]->child).push_back(``new` `Node(15)); ` `    ``(root->child[0]->child).push_back(``new` `Node(25)); ` `    ``(root->child[0]->child[1]->child).push_back(``new` `Node(70)); ` `    ``(root->child[0]->child[1]->child).push_back(``new` `Node(100)); ` `    ``(root->child[1]->child).push_back(``new` `Node(6)); ` `    ``(root->child[1]->child).push_back(``new` `Node(1)); ` `    ``(root->child[2]->child).push_back(``new` `Node(7)); ` `    ``(root->child[2]->child[0]->child).push_back(``new` `Node(17)); ` `    ``(root->child[2]->child[0]->child).push_back(``new` `Node(99)); ` `    ``(root->child[2]->child[0]->child).push_back(``new` `Node(27)); ` `    ``(root->child[3]->child).push_back(``new` `Node(16)); ` ` `  `    ``// Node whose number of ` `    ``// siblings is to be calculated ` `    ``int` `x = 100; ` ` `  `    ``// Function calling ` `    ``cout << numberOfSiblings(root, x) << endl; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find number  ` `// of siblings of a given node  ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `     `  `// Represents a node of an n-ary tree  ` `static` `class` `Node  ` `{  ` `    ``int` `key;  ` `    ``Vector child;  ` ` `  `    ``Node(``int` `data)  ` `    ``{  ` `        ``key = data;  ` `        ``child = ``new` `Vector(); ` `    ``}  ` `};  ` ` `  `// Function to calculate number  ` `// of siblings of a given node  ` `static` `int` `numberOfSiblings(Node root, ``int` `x)  ` `{  ` `    ``if` `(root == ``null``)  ` `        ``return` `0``;  ` ` `  `    ``// Creating a queue and  ` `    ``// pushing the root  ` `    ``Queue q = ``new` `LinkedList<>();  ` `    ``q.add(root);  ` ` `  `    ``while` `(q.size() > ``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();  ` ` `  `        ``// Enqueue all children of  ` `        ``// the dequeued item  ` `        ``for` `(``int` `i = ``0``; i < p.child.size(); i++)  ` `        ``{  ` `            ``// If the value of children  ` `            ``// is equal to x, then return  ` `            ``// the number of siblings  ` `            ``if` `(p.child.get(i).key == x)  ` `                ``return` `p.child.size() - ``1``;  ` `            ``q.add(p.child.get(i));  ` `        ``}  ` `    ``}  ` `    ``return` `-``1``; ` `}  ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{  ` `    ``// Creating a generic tree as shown in above figure  ` `    ``Node root = ``new` `Node(``50``);  ` `    ``(root.child).add(``new` `Node(``2``));  ` `    ``(root.child).add(``new` `Node(``30``));  ` `    ``(root.child).add(``new` `Node(``14``));  ` `    ``(root.child).add(``new` `Node(``60``));  ` `    ``(root.child.get(``0``).child).add(``new` `Node(``15``));  ` `    ``(root.child.get(``0``).child).add(``new` `Node(``25``));  ` `    ``(root.child.get(``0``).child.get(``1``).child).add(``new` `Node(``70``));  ` `    ``(root.child.get(``0``).child.get(``1``).child).add(``new` `Node(``100``));  ` `    ``(root.child.get(``1``).child).add(``new` `Node(``6``));  ` `    ``(root.child.get(``1``).child).add(``new` `Node(``1``));  ` `    ``(root.child.get(``2``).child).add(``new` `Node(``7``));  ` `    ``(root.child.get(``2``).child.get(``0``).child).add(``new` `Node(``17``));  ` `    ``(root.child.get(``2``).child.get(``0``).child).add(``new` `Node(``99``));  ` `    ``(root.child.get(``2``).child.get(``0``).child).add(``new` `Node(``27``));  ` `    ``(root.child.get(``3``).child).add(``new` `Node(``16``));  ` ` `  `    ``// Node whose number of  ` `    ``// siblings is to be calculated  ` `    ``int` `x = ``100``;  ` ` `  `    ``// Function calling  ` `    ``System.out.println( numberOfSiblings(root, x) );  ` `} ` `}  ` ` `  `// This code is contributed by Arnab Kundu `

## Python3

 `# Python3 program to find number  ` `# of siblings of a given node  ` `from` `queue ``import` `Queue  ` ` `  `# Represents a node of an n-ary tree  ` `class` `newNode:  ` `    ``def` `__init__(``self``,data): ` `        ``self``.child ``=` `[] ` `        ``self``.key ``=` `data ` ` `  `# Function to calculate number  ` `# of siblings of a given node  ` `def` `numberOfSiblings(root, x): ` `    ``if` `(root ``=``=` `None``):  ` `        ``return` `0` ` `  `    ``# Creating a queue and  ` `    ``# pushing the root  ` `    ``q ``=` `Queue() ` `    ``q.put(root)  ` ` `  `    ``while` `(``not` `q.empty()):  ` `         `  `        ``# Dequeue an item from queue and  ` `        ``# check if it is equal to x If YES,  ` `        ``# then return number of children  ` `        ``p ``=` `q.queue[``0``]  ` `        ``q.get()  ` ` `  `        ``# Enqueue all children of  ` `        ``# the dequeued item ` `        ``for` `i ``in` `range``(``len``(p.child)): ` `             `  `            ``# If the value of children  ` `            ``# is equal to x, then return  ` `            ``# the number of siblings  ` `            ``if` `(p.child[i].key ``=``=` `x):  ` `                ``return` `len``(p.child) ``-` `1` `            ``q.put(p.child[i]) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``# Creating a generic tree as  ` `    ``# shown in above figure  ` `    ``root ``=` `newNode(``50``)  ` `    ``(root.child).append(newNode(``2``))  ` `    ``(root.child).append(newNode(``30``))  ` `    ``(root.child).append(newNode(``14``))  ` `    ``(root.child).append(newNode(``60``))  ` `    ``(root.child[``0``].child).append(newNode(``15``))  ` `    ``(root.child[``0``].child).append(newNode(``25``))  ` `    ``(root.child[``0``].child[``1``].child).append(newNode(``70``))  ` `    ``(root.child[``0``].child[``1``].child).append(newNode(``100``))  ` `    ``(root.child[``1``].child).append(newNode(``6``))  ` `    ``(root.child[``1``].child).append(newNode(``1``))  ` `    ``(root.child[``2``].child).append(newNode(``7``))  ` `    ``(root.child[``2``].child[``0``].child).append(newNode(``17``))  ` `    ``(root.child[``2``].child[``0``].child).append(newNode(``99``))  ` `    ``(root.child[``2``].child[``0``].child).append(newNode(``27``))  ` `    ``(root.child[``3``].child).append(newNode(``16``))  ` ` `  `    ``# Node whose number of  ` `    ``# siblings is to be calculated  ` `    ``x ``=` `100` ` `  `    ``# Function calling  ` `    ``print``(numberOfSiblings(root, x)) ` ` `  `# This code is contributed by PranchalK `

Output:

```1
```

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

## tags:

Queue Tree cpp-queue Queue Tree