Given a tree represented as undirected graph. Count the number of nodes at given level l. It may be assumed that vertex 0 is root of the tree.

Examples:

Input : 7 0 1 0 2 1 3 1 4 1 5 2 6 2 Output : 4 Input : 6 0 1 0 2 1 3 2 4 2 5 2 Output : 3

BFS is a traversing algorithm which start traversing from a selected node (source or starting node) and traverse the graph layer wise thus exploring the neighbour nodes (nodes which are directly connected to source node). Then, move towards the next-level neighbour nodes.

As the name BFS suggests, traverse the graph breadth wise as follows:

**1.** First move horizontally and visit all the nodes of the current layer.

**2.** Move to the next layer.

In this code, while visiting each node, the level of that node is set with an increment in the level of its parent node i.e., level[child] = level[parent] + 1. This is how the level of each node is determined. The root node lies at level zero in the tree.

**Explanation :**

0 Level 0 / \ 1 2 Level 1 / |\ | 3 4 5 6 Level 2

Given a tree with 7 nodes and 6 edges in which node 0 lies at 0 level. Level of 1 can be updated as : level[1] = level[0] +1 as 0 is the parent node of 1. Similarly, the level of other nodes can be updated by adding 1 to the level of their parent.

level[2] = level[0] + 1, i.e level[2] = 0 + 1 = 1.

level[3] = level[1] + 1, i.e level[3] = 1 + 1 = 2.

level[4] = level[1] + 1, i.e level[4] = 1 + 1 = 2.

level[5] = level[1] + 1, i.e level[5] = 1 + 1 = 2.

level[6] = level[2] + 1, i.e level[6] = 1 + 1 = 2.

Then, count of number of nodes which are at level l(i.e, l=2) is 4 (node:- 3, 4, 5, 6)

## C++

`// C++ Program to print ` `// count of nodes ` `// at given level. ` `#include <iostream> ` `#include <list> ` ` ` `using` `namespace` `std; ` ` ` `// This class represents ` `// a directed graph ` `// using adjacency ` `// list representation ` `class` `Graph { ` ` ` `// No. of vertices ` ` ` `int` `V; ` ` ` ` ` `// Pointer to an ` ` ` `// array containing ` ` ` `// adjacency lists ` ` ` `list<` `int` `>* adj; ` ` ` `public` `: ` ` ` `// Constructor ` ` ` `Graph(` `int` `V); ` ` ` ` ` `// function to add ` ` ` `// an edge to graph ` ` ` `void` `addEdge(` `int` `v, ` `int` `w); ` ` ` ` ` `// Returns count of nodes at ` ` ` `// level l from given source. ` ` ` `int` `BFS(` `int` `s, ` `int` `l); ` `}; ` ` ` `Graph::Graph(` `int` `V) ` `{ ` ` ` `this` `->V = V; ` ` ` `adj = ` `new` `list<` `int` `>[V]; ` `} ` ` ` `void` `Graph::addEdge(` `int` `v, ` `int` `w) ` `{ ` ` ` `// Add w to v’s list. ` ` ` `adj[v].push_back(w); ` ` ` ` ` `// Add v to w's list. ` ` ` `adj[w].push_back(v); ` `} ` ` ` `int` `Graph::BFS(` `int` `s, ` `int` `l) ` `{ ` ` ` `// Mark all the vertices ` ` ` `// as not visited ` ` ` `bool` `* visited = ` `new` `bool` `[V]; ` ` ` `int` `level[V]; ` ` ` ` ` `for` `(` `int` `i = 0; i < V; i++) { ` ` ` `visited[i] = ` `false` `; ` ` ` `level[i] = 0; ` ` ` `} ` ` ` ` ` `// Create a queue for BFS ` ` ` `list<` `int` `> queue; ` ` ` ` ` `// Mark the current node as ` ` ` `// visited and enqueue it ` ` ` `visited[s] = ` `true` `; ` ` ` `queue.push_back(s); ` ` ` `level[s] = 0; ` ` ` ` ` `while` `(!queue.empty()) { ` ` ` ` ` `// Dequeue a vertex from ` ` ` `// queue and print it ` ` ` `s = queue.front(); ` ` ` `queue.pop_front(); ` ` ` ` ` `// Get all adjacent vertices ` ` ` `// of the dequeued vertex s. ` ` ` `// If a adjacent has not been ` ` ` `// visited, then mark it ` ` ` `// visited and enqueue it ` ` ` `for` `(` `auto` `i = adj[s].begin(); ` ` ` `i != adj[s].end(); ++i) { ` ` ` `if` `(!visited[*i]) { ` ` ` ` ` `// Setting the level ` ` ` `// of each node with ` ` ` `// an increment in the ` ` ` `// level of parent node ` ` ` `level[*i] = level[s] + 1; ` ` ` `visited[*i] = ` `true` `; ` ` ` `queue.push_back(*i); ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` ` ` `int` `count = 0; ` ` ` `for` `(` `int` `i = 0; i < V; i++) ` ` ` `if` `(level[i] == l) ` ` ` `count++; ` ` ` `return` `count; ` `} ` ` ` `// Driver program to test ` `// methods of graph class ` `int` `main() ` `{ ` ` ` `// Create a graph given ` ` ` `// in the above diagram ` ` ` `Graph g(6); ` ` ` `g.addEdge(0, 1); ` ` ` `g.addEdge(0, 2); ` ` ` `g.addEdge(1, 3); ` ` ` `g.addEdge(2, 4); ` ` ` `g.addEdge(2, 5); ` ` ` ` ` `int` `level = 2; ` ` ` ` ` `cout << g.BFS(0, level); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output:

3

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:

- Count the number of nodes at a given level in a tree using DFS
- Count nodes with two children at level L in a Binary Tree
- Level with maximum number of nodes using DFS in a N-ary tree
- Difference between sums of odd level and even level nodes of a Binary Tree
- Given a n-ary tree, count number of nodes which have more number of children than parents
- Count the nodes in the given tree whose weight is a powerful number
- Count the number of visible nodes in Binary Tree
- Count the nodes in the given Tree whose weight is a Perfect Number
- Count nodes in the given tree whose weight is a fibonacci number
- Count the nodes of the tree which make a pangram when concatenated with the sub-tree nodes
- Sum of all nodes at Kth level in a Binary Tree
- Swap Nodes in Binary tree of every k'th level
- Sum of nodes at k-th level in a tree represented as string
- Nodes at Kth level without duplicates in a Binary Tree
- Product of nodes at k-th level in a tree represented as string
- Print nodes between two given level numbers of a binary tree
- Product of nodes at k-th level in a tree represented as string using Recursion
- Print all nodes except rightmost node of every level of the Binary Tree
- Print all the nodes except the leftmost node in every level of the given binary tree
- Print odd positioned nodes of even levels in level order of the given binary tree

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.