Given a N-ary tree represented as adjacency list, we need to write a program to count all such nodes in this tree which has more number of children than its parent.

For Example,

In the above tree, the count will be 1 as there is only one such node which is ‘2’ which has more number of children than its parent. 2 has three children (4, 5 and 6) whereas its parent, 1 has only two children (2 and 3).

We can solve this problem using both BFS and DFS algorithms. We will explain here in details about how to solve this problem using BFS algorithm.

As the tree is represented using adjacency list representation. So, for any node say ‘u’ the number of children of this node can be given as adj[u].size().

Now the idea is to apply BFS on the given tree and while traversing the children of a node ‘u’ say ‘v’ we will simply check is adj[v].size() > adj[u].size().

Below is the implementation of above idea:

## CPP

`// C++ program to count number of nodes ` `// which has more children than its parent ` ` ` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// function to count number of nodes ` `// which has more children than its parent ` `int` `countNodes(vector<` `int` `> adj[], ` `int` `root) ` `{ ` ` ` `int` `count = 0; ` ` ` ` ` `// queue for applying BFS ` ` ` `queue<` `int` `> q; ` ` ` ` ` `// BFS algorithm ` ` ` `q.push(root); ` ` ` ` ` `while` `(!q.empty()) ` ` ` `{ ` ` ` `int` `node = q.front(); ` ` ` `q.pop(); ` ` ` ` ` `// traverse children of node ` ` ` `for` `( ` `int` `i=0;i<adj[node].size();i++) ` ` ` `{ ` ` ` `// children of node ` ` ` `int` `children = adj[node][i]; ` ` ` ` ` `// if number of childs of children ` ` ` `// is greater than number of childs ` ` ` `// of node, then increment count ` ` ` `if` `(adj[children].size() > adj[node].size()) ` ` ` `count++; ` ` ` `q.push(children); ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `count; ` `} ` ` ` `// Driver program to test above functions ` `int` `main() ` `{ ` ` ` `// adjacency list for n-ary tree ` ` ` `vector<` `int` `> adj[10]; ` ` ` ` ` `// construct n ary tree as shown ` ` ` `// in above diagram ` ` ` `adj[1].push_back(2); ` ` ` `adj[1].push_back(3); ` ` ` `adj[2].push_back(4); ` ` ` `adj[2].push_back(5); ` ` ` `adj[2].push_back(6); ` ` ` `adj[3].push_back(9); ` ` ` `adj[5].push_back(7); ` ` ` `adj[5].push_back(8); ` ` ` ` ` `int` `root = 1; ` ` ` ` ` `cout << countNodes(adj, root); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to count number of nodes ` `// which has more children than its parent ` `import` `java.util.*; ` ` ` `class` `GFG ` `{ ` ` ` `// function to count number of nodes ` `// which has more children than its parent ` `static` `int` `countNodes(Vector<Integer> adj[], ` `int` `root) ` `{ ` ` ` `int` `count = ` `0` `; ` ` ` ` ` `// queue for applying BFS ` ` ` `Queue<Integer> q = ` `new` `LinkedList<>(); ` ` ` ` ` `// BFS algorithm ` ` ` `q.add(root); ` ` ` ` ` `while` `(!q.isEmpty()) ` ` ` `{ ` ` ` `int` `node = q.peek(); ` ` ` `q.remove(); ` ` ` ` ` `// traverse children of node ` ` ` `for` `( ` `int` `i=` `0` `;i<adj[node].size();i++) ` ` ` `{ ` ` ` `// children of node ` ` ` `int` `children = adj[node].get(i); ` ` ` ` ` `// if number of childs of children ` ` ` `// is greater than number of childs ` ` ` `// of node, then increment count ` ` ` `if` `(adj[children].size() > adj[node].size()) ` ` ` `count++; ` ` ` `q.add(children); ` ` ` `} ` ` ` `} ` ` ` `return` `count; ` `} ` ` ` `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` `// adjacency list for n-array tree ` ` ` `Vector<Integer> []adj = ` `new` `Vector[` `10` `]; ` ` ` `for` `(` `int` `i= ` `0` `; i < ` `10` `; i++) { ` ` ` `adj[i] = ` `new` `Vector<>(); ` ` ` `} ` ` ` ` ` `// conn array tree as shown ` ` ` `// in above diagram ` ` ` `adj[` `1` `].add(` `2` `); ` ` ` `adj[` `1` `].add(` `3` `); ` ` ` `adj[` `2` `].add(` `4` `); ` ` ` `adj[` `2` `].add(` `5` `); ` ` ` `adj[` `2` `].add(` `6` `); ` ` ` `adj[` `3` `].add(` `9` `); ` ` ` `adj[` `5` `].add(` `7` `); ` ` ` `adj[` `5` `].add(` `8` `); ` ` ` ` ` `int` `root = ` `1` `; ` ` ` ` ` `System.out.print(countNodes(adj, root)); ` `} ` `} ` ` ` `// This code is contributed by Rajput-Ji ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to count number of nodes ` `# which has more children than its parent ` `from` `collections ` `import` `deque ` ` ` `adj ` `=` `[[] ` `for` `i ` `in` `range` `(` `100` `)] ` ` ` `# function to count number of nodes ` `# which has more children than its parent ` `def` `countNodes(root): ` ` ` ` ` `count ` `=` `0` ` ` ` ` `# queue for applying BFS ` ` ` `q ` `=` `deque() ` ` ` ` ` `# BFS algorithm ` ` ` `q.append(root) ` ` ` ` ` `while` `len` `(q) > ` `0` `: ` ` ` ` ` `node ` `=` `q.popleft() ` ` ` ` ` `# traverse children of node ` ` ` `for` `i ` `in` `adj[node]: ` ` ` `# children of node ` ` ` `children ` `=` `i ` ` ` ` ` `# if number of childs of children ` ` ` `# is greater than number of childs ` ` ` `# of node, then increment count ` ` ` `if` `(` `len` `(adj[children]) > ` `len` `(adj[node])): ` ` ` `count ` `+` `=` `1` ` ` `q.append(children) ` ` ` ` ` `return` `count ` ` ` ` ` `# Driver program to test above functions ` ` ` `# construct n ary tree as shown ` `# in above diagram ` `adj[` `1` `].append(` `2` `) ` `adj[` `1` `].append(` `3` `) ` `adj[` `2` `].append(` `4` `) ` `adj[` `2` `].append(` `5` `) ` `adj[` `2` `].append(` `6` `) ` `adj[` `3` `].append(` `9` `) ` `adj[` `5` `].append(` `7` `) ` `adj[` `5` `].append(` `8` `) ` ` ` `root ` `=` `1` ` ` `print` `(countNodes(root)) ` ` ` `# This code is contributed by mohit kumar 29 ` |

*chevron_right*

*filter_none*

## C#

`// C# program to count number of nodes ` `// which has more children than its parent ` `using` `System; ` `using` `System.Collections.Generic; ` ` ` `class` `GFG ` `{ ` ` ` `// function to count number of nodes ` `// which has more children than its parent ` `static` `int` `countNodes(List<` `int` `> []adj, ` `int` `root) ` `{ ` ` ` `int` `count = 0; ` ` ` ` ` `// queue for applying BFS ` ` ` `List<` `int` `> q = ` `new` `List<` `int` `>(); ` ` ` ` ` `// BFS algorithm ` ` ` `q.Add(root); ` ` ` ` ` `while` `(q.Count != 0) ` ` ` `{ ` ` ` `int` `node = q[0]; ` ` ` `q.RemoveAt(0); ` ` ` ` ` `// traverse children of node ` ` ` `for` `( ` `int` `i = 0; i < adj[node].Count; i++) ` ` ` `{ ` ` ` `// children of node ` ` ` `int` `children = adj[node][i]; ` ` ` ` ` `// if number of childs of children ` ` ` `// is greater than number of childs ` ` ` `// of node, then increment count ` ` ` `if` `(adj[children].Count > adj[node].Count) ` ` ` `count++; ` ` ` `q.Add(children); ` ` ` `} ` ` ` `} ` ` ` `return` `count; ` `} ` ` ` `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` ` ` `// adjacency list for n-array tree ` ` ` `List<` `int` `> []adj = ` `new` `List<` `int` `>[10]; ` ` ` `for` `(` `int` `i= 0; i < 10 ; i++) { ` ` ` `adj[i] = ` `new` `List<` `int` `>(); ` ` ` `} ` ` ` ` ` `// conn array tree as shown ` ` ` `// in above diagram ` ` ` `adj[1].Add(2); ` ` ` `adj[1].Add(3); ` ` ` `adj[2].Add(4); ` ` ` `adj[2].Add(5); ` ` ` `adj[2].Add(6); ` ` ` `adj[3].Add(9); ` ` ` `adj[5].Add(7); ` ` ` `adj[5].Add(8); ` ` ` ` ` `int` `root = 1; ` ` ` ` ` `Console.Write(countNodes(adj, root)); ` `} ` `} ` ` ` `// This code is contributed by PrinciRaj1992 ` |

*chevron_right*

*filter_none*

**Output:**

1

**Time Complexity**: O( n ) , where n is the number of nodes in the tree.

This article is contributed by **Harsh Agarwal**. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- General Tree (Each node can have arbitrary number of children) Level Order Traversal
- Minimum number of Nodes to be removed such that no subtree has more than K nodes
- Count nodes with two children at level L in a Binary Tree
- Count of nodes in a Binary tree with immediate children as its factors
- Count of nodes in a Binary Tree whose immediate children are co-prime
- Count the nodes of the tree which make a pangram when concatenated with the sub-tree nodes
- Count of Nodes whose both immediate children are its prime factors
- Convert an arbitrary Binary Tree to a tree that holds Children Sum Property
- Check which player visits more number of Nodes
- Number of children of given node in n-ary Tree
- Count of all prime weight nodes between given nodes in the given Tree
- Find root of the tree where children id sum for every node is given
- Find the number of distinct pairs of vertices which have a distance of exactly k in a tree
- Check for Children Sum Property in a Binary Tree
- Node having maximum sum of immediate children and itself in n-ary tree
- Maximum parent children sum in Binary tree
- Iterative approach to check for children sum property in a Binary Tree
- Count nodes from all lower levels smaller than minimum valued node of current level for every level in a Binary Tree
- Number of nodes greater than a given value in n-ary tree
- Count of Nodes which has Prime Digit sum weight in a Tree