# Level with maximum number of nodes

Find the level in a binary tree that has the maximum number of nodes. The root is at level 0.

Examples:

`Input: `

```Output : 2
Explanation:```

`Input:`

```Output:1
Explanation```

` `
Recommended Practice

Approach: It is known that in level order traversal of binary tree with queue, at any time our queue contains all elements of a particular level. So find level with maximum number of nodes in queue.
BFS traversal is an algorithm for traversing or searching tree or graphs . It starts at the tree root , and explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level.
So at any point the queue of BFS will contain elements of adjacent layers. So this makes the algorithm perfect for this problem.

Algorithm:

1. Create the tree, a queue to store the nodes and insert the root in the queue. Create variables level=0,count =0 and level_no=-1
2. The implementation will be slightly different, all the elements of same level will be removed in a single iteration.
3. Run a loop while size of queue is greater than 0. Get the size of queue (size) and store it. If size is greater than count then update count = size and level_no = level.
4. Now run a loop size times, and pop one node from the queue and insert its childrens (if present).
5. Increment level.

Implementation:

## C++

 `// C++ implementation to find the level` `// having maximum number of Nodes` `#include ` `using` `namespace` `std;`   `/* A binary tree Node has data, pointer` `   ``to left child and a pointer to right` `   ``child */` `struct` `Node` `{` `    ``int` `data;` `    ``struct` `Node* left;` `    ``struct` `Node* right;` `};`   `/* Helper function that allocates a new node with the` `   ``given data and NULL left and right pointers. */` `struct` `Node* newNode(``int` `data)` `{` `    ``struct` `Node* node = ``new` `Node;` `    ``node->data = data;` `    ``node->left = NULL;` `    ``node->right = NULL;` `    ``return``(node);` `}`   `// function to find the level` `// having maximum number of Nodes` `int` `maxNodeLevel(Node *root)` `{` `    ``if` `(root == NULL)` `        ``return` `-1;`   `    ``queue q;` `    ``q.push(root);`   `    ``// Current level` `    ``int` `level = 0;`   `    ``// Maximum Nodes at same level` `    ``int` `max = INT_MIN;`   `    ``// Level having maximum Nodes` `    ``int` `level_no = 0;`   `    ``while` `(1)` `    ``{` `        ``// Count Nodes in a level` `        ``int` `NodeCount = q.size();`   `        ``if` `(NodeCount == 0)` `            ``break``;`   `        ``// If it is maximum till now` `        ``// Update level_no to current level` `        ``if` `(NodeCount > max)` `        ``{` `            ``max = NodeCount;` `            ``level_no = level;` `        ``}`   `        ``// Pop complete current level` `        ``while` `(NodeCount > 0)` `        ``{` `            ``Node *Node = q.front();` `            ``q.pop();` `            ``if` `(Node->left != NULL)` `                ``q.push(Node->left);` `            ``if` `(Node->right != NULL)` `                ``q.push(Node->right);` `            ``NodeCount--;` `        ``}`   `        ``// Increment for next level` `        ``level++;` `    ``}`   `    ``return` `level_no;` `}`   `// Driver program to test above` `int` `main()` `{` `    ``// binary tree formation` `    ``struct` `Node *root = newNode(2);      ``/*        2      */` `    ``root->left        = newNode(1);      ``/*      /   \    */` `    ``root->right       = newNode(3);      ``/*     1     3      */` `    ``root->left->left  = newNode(4);      ``/*   /   \    \  */` `    ``root->left->right = newNode(6);      ``/*  4     6    8 */` `    ``root->right->right  = newNode(8);    ``/*       /       */` `    ``root->left->right->left = newNode(5);``/*      5        */`   `    ``printf``(``"Level having maximum number of Nodes : %d"``,` `            ``maxNodeLevel(root));` `    ``return` `0;` `}`

## Java

 `// Java implementation to find the level ` `// having maximum number of Nodes ` `import` `java.util.*;` `class` `GfG { `   `/* A binary tree Node has data, pointer ` `to left child and a pointer to right ` `child */` `static` `class` `Node ` `{ ` `    ``int` `data; ` `    ``Node left; ` `    ``Node right; ` `}`   `/* Helper function that allocates a new node with the ` `given data and NULL left and right pointers. */` `static` `Node newNode(``int` `data) ` `{ ` `    ``Node node = ``new` `Node(); ` `    ``node.data = data; ` `    ``node.left = ``null``; ` `    ``node.right = ``null``; ` `    ``return``(node); ` `} `   `// function to find the level ` `// having maximum number of Nodes ` `static` `int` `maxNodeLevel(Node root) ` `{ ` `    ``if` `(root == ``null``) ` `        ``return` `-``1``; `   `    ``Queue q = ``new` `LinkedList (); ` `    ``q.add(root); `   `    ``// Current level ` `    ``int` `level = ``0``; `   `    ``// Maximum Nodes at same level ` `    ``int` `max = Integer.MIN_VALUE; `   `    ``// Level having maximum Nodes ` `    ``int` `level_no = ``0``; `   `    ``while` `(``true``) ` `    ``{ ` `        ``// Count Nodes in a level ` `        ``int` `NodeCount = q.size(); `   `        ``if` `(NodeCount == ``0``) ` `            ``break``; `   `        ``// If it is maximum till now ` `        ``// Update level_no to current level ` `        ``if` `(NodeCount > max) ` `        ``{ ` `            ``max = NodeCount; ` `            ``level_no = level; ` `        ``} `   `        ``// Pop complete current level ` `        ``while` `(NodeCount > ``0``) ` `        ``{ ` `            ``Node Node = q.peek(); ` `            ``q.remove(); ` `            ``if` `(Node.left != ``null``) ` `                ``q.add(Node.left); ` `            ``if` `(Node.right != ``null``) ` `                ``q.add(Node.right); ` `            ``NodeCount--; ` `        ``} `   `        ``// Increment for next level ` `        ``level++; ` `    ``} `   `    ``return` `level_no; ` `} `   `// Driver program to test above ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``// binary tree formation ` `     ``Node root = newNode(``2``);     ``/*     2     */` `    ``root.left     = newNode(``1``);     ``/*     / \ */` `    ``root.right     = newNode(``3``);     ``/*     1     3     */` `    ``root.left.left = newNode(``4``);     ``/* / \ \ */` `    ``root.left.right = newNode(``6``);     ``/* 4     6 8 */` `    ``root.right.right = newNode(``8``); ``/*     /     */` `    ``root.left.right.left = newNode(``5``);``/*     5     */`   `    ``System.out.println(``"Level having maximum number of Nodes : "` `+ maxNodeLevel(root)); ` `}` `} `

## Python3

 `# Python3 implementation to find the ` `# level having Maximum number of Nodes`   `# Importing Queue` `from` `queue ``import` `Queue `   `# Helper class that allocates a new ` `# node with the given data and None` `# left and right pointers. ` `class` `newNode:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# function to find the level ` `# having Maximum number of Nodes ` `def` `maxNodeLevel(root):` `    ``if` `(root ``=``=` `None``): ` `        ``return` `-``1`   `    ``q ``=` `Queue() ` `    ``q.put(root) `   `    ``# Current level ` `    ``level ``=` `0`   `    ``# Maximum Nodes at same level ` `    ``Max` `=` `-``999999999999`   `    ``# Level having Maximum Nodes ` `    ``level_no ``=` `0`   `    ``while` `(``1``):` `        `  `        ``# Count Nodes in a level ` `        ``NodeCount ``=` `q.qsize() `   `        ``if` `(NodeCount ``=``=` `0``):` `            ``break`   `        ``# If it is Maximum till now ` `        ``# Update level_no to current level ` `        ``if` `(NodeCount > ``Max``):` `            ``Max` `=` `NodeCount ` `            ``level_no ``=` `level`   `        ``# Pop complete current level ` `        ``while` `(NodeCount > ``0``):` `            ``Node ``=` `q.queue[``0``] ` `            ``q.get()` `            ``if` `(Node.left !``=` `None``):` `                ``q.put(Node.left) ` `            ``if` `(Node.right !``=` `None``): ` `                ``q.put(Node.right) ` `            ``NodeCount ``-``=` `1`   `        ``# Increment for next level ` `        ``level ``+``=` `1`   `    ``return` `level_no`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# binary tree formation ` `    ``root ``=` `newNode(``2``)     ``#     2     ` `    ``root.left     ``=` `newNode(``1``)     ``#     / \ ` `    ``root.right     ``=` `newNode(``3``)     ``#     1     3     ` `    ``root.left.left ``=` `newNode(``4``)     ``# / \ \ ` `    ``root.left.right ``=` `newNode(``6``)     ``# 4     6 8 ` `    ``root.right.right ``=` `newNode(``8``) ``#     /     ` `    ``root.left.right.left ``=` `newNode(``5``)``#     5     `   `    ``print``(``"Level having Maximum number of Nodes : "``, ` `                                 ``maxNodeLevel(root))`   `# This code is contributed by Pranchalk`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `// C# implementation to find the level  ` `// having maximum number of Nodes  ` `public` `class` `GfG` `{`   `/* A binary tree Node has data, pointer  ` `to left child and a pointer to right  ` `child */` `public` `class` `Node` `{` `    ``public` `int` `data;` `    ``public` `Node left;` `    ``public` `Node right;` `}`   `/* Helper function that allocates a new node with the  ` `given data and NULL left and right pointers. */` `public` `static` `Node newNode(``int` `data)` `{` `    ``Node node = ``new` `Node();` `    ``node.data = data;` `    ``node.left = ``null``;` `    ``node.right = ``null``;` `    ``return` `(node);` `}`   `// function to find the level  ` `// having maximum number of Nodes  ` `public` `static` `int` `maxNodeLevel(Node root)` `{` `    ``if` `(root == ``null``)` `    ``{` `        ``return` `-1;` `    ``}`   `    ``LinkedList q = ``new` `LinkedList ();` `    ``q.AddLast(root);`   `    ``// Current level  ` `    ``int` `level = 0;`   `    ``// Maximum Nodes at same level  ` `    ``int` `max = ``int``.MinValue;`   `    ``// Level having maximum Nodes  ` `    ``int` `level_no = 0;`   `    ``while` `(``true``)` `    ``{` `        ``// Count Nodes in a level  ` `        ``int` `NodeCount = q.Count;`   `        ``if` `(NodeCount == 0)` `        ``{` `            ``break``;` `        ``}`   `        ``// If it is maximum till now  ` `        ``// Update level_no to current level  ` `        ``if` `(NodeCount > max)` `        ``{` `            ``max = NodeCount;` `            ``level_no = level;` `        ``}`   `        ``// Pop complete current level  ` `        ``while` `(NodeCount > 0)` `        ``{` `            ``Node Node = q.First.Value;` `            ``q.RemoveFirst();` `            ``if` `(Node.left != ``null``)` `            ``{` `                ``q.AddLast(Node.left);` `            ``}` `            ``if` `(Node.right != ``null``)` `            ``{` `                ``q.AddLast(Node.right);` `            ``}` `            ``NodeCount--;` `        ``}`   `        ``// Increment for next level  ` `        ``level++;` `    ``}`   `    ``return` `level_no;` `}`   `// Driver program to test above  ` `public` `static` `void` `Main(``string``[] args)` `{` `    ``// binary tree formation  ` `     ``Node root = newNode(2); ``//  2` `    ``root.left = newNode(1); ``//  / \` `    ``root.right = newNode(3); ``//  1   3` `    ``root.left.left = newNode(4); ``// / \ \` `    ``root.left.right = newNode(6); ``// 4    6 8` `    ``root.right.right = newNode(8); ``//    /` `    ``root.left.right.left = newNode(5); ``//     5`   `    ``Console.WriteLine(``"Level having maximum number of Nodes : "` `+ maxNodeLevel(root));` `}` `}`   `// This code is contributed by Shrikant13`

## Javascript

 ``

Output

`Level having maximum number of Nodes : 2`

Time Complexity: O(n), In BFS traversal every node is visited only once, So Time Complexity is O(n).
Auxiliary Space: O(n), The space is required to store the nodes in a queue.

An approach using DFS:

Iterate over the tree and for every nodes in the tree, count the frequency of nodes at particular height or depth.

• Create a map for counting the frequency of nodes at a particular height or depth.
• Iterate over the tree
• Increment the count of the number of nodes at a particular depth for every node.
• Iterate over the map and find the level that has the maximum number of nodes.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the approach` `#include ` `using` `namespace` `std;`   `// C++ implementation to find the level` `// having maximum number of Nodes` `#include ` `using` `namespace` `std;`   `/* A binary tree Node has data, pointer` `   ``to left child and a pointer to right` `   ``child */` `struct` `Node` `{` `    ``int` `data;` `    ``struct` `Node* left;` `    ``struct` `Node* right;` `};`   `/* Helper function that allocates a new node with the` `   ``given data and NULL left and right pointers. */` `struct` `Node* newNode(``int` `data)` `{` `    ``struct` `Node* node = ``new` `Node;` `    ``node->data = data;` `    ``node->left = NULL;` `    ``node->right = NULL;` `    ``return``(node);` `}`     `void` `dfs(Node* root,unordered_map<``int``, ``int``> &unmap, ``int` `depth){` `    ``if``(root == NULL) ``return``;` `    `  `    ``// Increment the count of nodes at depth in map` `    ``unmap[depth]++;` `    `  `    ``dfs(root->left,unmap, depth + 1);` `    ``dfs(root->right, unmap, depth + 1);` `}`   `int` `maxNodeLevel(Node *root)` `{` `    ``unordered_map<``int``, ``int``> unmap;` `    ``dfs(root, unmap, 0);` `    ``int` `maxx = INT_MIN, result;` `    `  `    ``for``(``auto` `it : unmap){` `        ``if``(it.second > maxx){` `            ``result = it.first;` `            ``maxx = it.second;` `        ``}` `        ``else` `if``(it.second == maxx){` `            ``result = min(result, it.first);` `        ``}` `    ``}` `    `  `    ``return` `result;` `}`   `// Driver program to test above` `int` `main()` `{` `    ``// binary tree formation` `    ``struct` `Node *root = newNode(2);      ``/*        2      */` `    ``root->left        = newNode(1);      ``/*      /   \    */` `    ``root->right       = newNode(3);      ``/*     1     3      */` `    ``root->left->left  = newNode(4);      ``/*   /   \    \  */` `    ``root->left->right = newNode(6);      ``/*  4     6    8 */` `    ``root->right->right  = newNode(8);    ``/*       /       */` `    ``root->left->right->left = newNode(5);``/*      5        */`   `    ``printf``(``"Level having maximum number of Nodes : %d"``,` `            ``maxNodeLevel(root));` `    ``return` `0;` `}`   `// This code is contributed by hkdass001`

## Java

 `// Java implementation to find the level having` `// maximum number of nodes` `import` `java.util.*;` `class` `GFG{` `    ``/* A binary tree Node has data, pointer` `    ``to left child and a pointer to right` `    ``child */` `    ``static` `class` `Node{` `        ``int` `data;` `        ``Node left;` `        ``Node right;` `    ``}` `    `  `    ``/* Helper function that allocates a new node with the` `    ``given data and NULL left and right pointers. */`   `    ``static` `Node newNode(``int` `data){` `        ``Node node = ``new` `Node();` `        ``node.data = data;` `        ``node.left = ``null``;` `        ``node.right = ``null``;` `        ``return` `node;` `    ``}` `    `  `    ``static` `void` `dfs(Node root, Map unmap, ``int` `depth){` `        ``if``(root == ``null``) ``return``;` `        `  `        ``// Increment the count of nodes at depth in map` `        ``if``(unmap.containsKey(depth)){` `            ``unmap.put(depth, unmap.get(depth)+``1``);` `        ``}``else``{` `            ``unmap.put(depth, ``1``);` `        ``}` `        ``// unmap.put(depth, unmap.get(depth) + 1);` `        ``dfs(root.left, unmap, depth+``1``);` `        ``dfs(root.right, unmap, depth+``1``);` `    ``}` `    `  `    ``// function to find the level` `    ``// having maximum number of Nodes` `    ``static` `int` `maxNodeLevel(Node root){` `        ``Map unmap = ``new` `HashMap();` `        ``dfs(root, unmap, ``0``);` `        ``int` `maxx = Integer.MIN_VALUE;` `        ``int` `result = ``0``;` `        `  `        ``for``(Integer i : unmap.keySet()){` `            ``if``(unmap.get(i) > maxx){` `                ``result = i;` `                ``maxx = unmap.get(i);` `            ``}` `            ``else` `if``(unmap.get(i) == maxx){` `                ``result = Math.min(result, i);` `            ``}` `            ``// System.out.println(i + " -> " + unmap.get(i));` `        ``}` `        ``return` `result;` `    ``}` `    `  `    ``// Driver program to test above` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// binary tree formation` `        ``Node root = newNode(``2``);           ``/*        2         */` `        ``root.left        = newNode(``1``);    ``/*      /   \       */` `        ``root.right       = newNode(``3``);    ``/*     1     3      */` `        ``root.left.left  = newNode(``4``);     ``/*   /   \    \     */` `        ``root.left.right = newNode(``6``);     ``/*  4     6    8    */` `        ``root.right.right  = newNode(``8``);   ``/*       /          */` `        ``root.left.right.left = newNode(``5``);``/*      5           */` `     `  `        ``System.out.println(``"Level having maximum number of Nodes : "` `+ maxNodeLevel(root));` `    ``}` `}`   `// This code is contributed by Kirti Agarwal`

## Python3

 `# Python implementation to find the level` `# having maximum number of Nodes`   `class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `def` `dfs(root, unmap, depth):` `    ``if` `root ``is` `None``:` `        ``return` `    ``# Initialize the count of nodes at depth in map to 0` `    ``unmap[depth] ``=` `unmap.get(depth, ``0``) ``+` `1` `    ``dfs(root.left, unmap, depth ``+` `1``)` `    ``dfs(root.right, unmap, depth ``+` `1``)`     `def` `maxNodeLevel(root):` `    ``unmap ``=` `{}` `    ``dfs(root, unmap, ``0``)` `    ``maxx ``=` `float``(``'-inf'``)` `    ``result ``=` `None` `    ``for` `k, v ``in` `unmap.items():` `        ``if` `v > maxx:` `            ``result ``=` `k` `            ``maxx ``=` `v` `        ``elif` `v ``=``=` `maxx:` `            ``result ``=` `min``(result, k)` `    ``return` `result`   `# Driver program to test above` `if` `__name__ ``=``=` `"__main__"``:` `    ``# binary tree formation` `    ``root ``=` `Node(``2``)                       ``#   2` `    ``root.left ``=` `Node(``1``)                  ``#  / \` `    ``root.right ``=` `Node(``3``)                 ``# 1   3` `    ``root.left.left ``=` `Node(``4``)            ``# / \  \` `    ``root.left.right ``=` `Node(``6``)          ``# 4   6  8` `    ``root.right.right ``=` `Node(``8``)            ``# /` `    ``root.left.right.left ``=` `Node(``5``)       ``# 5`   `    ``print``(``"Level having maximum number of Nodes:"``, maxNodeLevel(root))`

## Javascript

 `// JavaScript implementation to find the level` `// having maximum number of nodes`   `// A binary tree node has data, pointer ` `// to left child and a pointer to right child` `class Node{` `    ``constructor(data){` `        ``this``.data = data;` `        ``this``.left = ``null``;` `        ``this``.right = ``null``;` `    ``}` `}`   `// Helper Function that allocated a new node with the` `// given data and null left and right pointers` `function` `newNode(data){` `    ``let node = ``new` `Node(data);` `    ``return` `node;` `}`   `function` `dfs(root, unmap, depth){` `    ``if``(root == ``null``) ``return``;` `    `  `    ``// Increment the count of nodes at depth in map` `    ``if``(unmap.has(depth))` `        ``unmap.set(depth, unmap.get(depth)+1);` `    ``else` `        ``unmap.set(depth, 1);` `    ``dfs(root.left, unmap, depth+1);` `    ``dfs(root.right, unmap, depth+1);` `}`   `function` `maxNodeLevel(root){` `    ``let unmap = ``new` `Map();` `    ``dfs(root, unmap, 0);` `    ``let maxx = Number.MIN_VALUE;` `    ``let result;` `    `  `    ``unmap.forEach(``function``(value, key){` `        ``if``(value > maxx){` `            ``result = key;` `            ``maxx = value;` `        ``}``else` `if``(value == maxx){` `            ``result = Math.min(result, key);` `        ``}` `    ``})` `    `  `    ``return` `result;` `}`   `// Driver program to test above` `// binary tree formation` `let root = newNode(2);            ``/*        2         */` `root.left        = newNode(1);    ``/*      /   \       */` `root.right       = newNode(3);    ``/*     1     3      */` `root.left.left  = newNode(4);     ``/*   /   \    \     */` `root.left.right = newNode(6);     ``/*  4     6    8    */` `root.right.right  = newNode(8);   ``/*       /          */` `root.left.right.left = newNode(5);``/*      5           */`   `console.log(``"Level having maximum number of Nodes : "` `+ maxNodeLevel(root));`   `// This code is contributed by Yash Agarwal`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG` `{` `    ``// A binary tree Node has data, pointer to left child and a pointer to right child` `    ``public` `class` `Node` `    ``{` `        ``public` `int` `data;` `        ``public` `Node left;` `        ``public` `Node right;` `    ``}`   `    ``// Helper function that allocates a new node with the given data and NULL left and right pointers.` `    ``public` `static` `Node NewNode(``int` `data)` `    ``{` `        ``Node node = ``new` `Node();` `        ``node.data = data;` `        ``node.left = ``null``;` `        ``node.right = ``null``;` `        ``return` `node;` `    ``}`   `    ``public` `static` `void` `Dfs(Node root, Dictionary<``int``, ``int``> unmap, ``int` `depth)` `    ``{` `        ``if` `(root == ``null``)` `        ``{` `            ``return``;` `        ``}`   `        ``// Increment the count of nodes at depth in map` `        ``if` `(unmap.ContainsKey(depth))` `        ``{` `            ``unmap[depth]++;` `        ``}` `        ``else` `        ``{` `            ``unmap.Add(depth, 1);` `        ``}`   `        ``Dfs(root.left, unmap, depth + 1);` `        ``Dfs(root.right, unmap, depth + 1);` `    ``}`   `    ``// Function to find the level having maximum number of nodes` `    ``public` `static` `int` `MaxNodeLevel(Node root)` `    ``{` `        ``Dictionary<``int``, ``int``> unmap = ``new` `Dictionary<``int``, ``int``>();` `        ``Dfs(root, unmap, 0);` `        ``int` `maxx = ``int``.MinValue;` `        ``int` `result = 0;`   `        ``foreach` `(``int` `i ``in` `unmap.Keys)` `        ``{` `            ``if` `(unmap[i] > maxx)` `            ``{` `                ``result = i;` `                ``maxx = unmap[i];` `            ``}` `            ``else` `if` `(unmap[i] == maxx)` `            ``{` `                ``result = Math.Min(result, i);` `            ``}` `        ``}`   `        ``return` `result;` `    ``}`   `    ``// Driver program to test above` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``// binary tree formation` `        ``Node root = NewNode(2);           ``/*        2         */` `        ``root.left = NewNode(1);           ``/*      /   \       */` `        ``root.right = NewNode(3);          ``/*     1     3      */` `        ``root.left.left = NewNode(4);      ``/*   /   \    \     */` `        ``root.left.right = NewNode(6);     ``/*  4     6    8    */` `        ``root.right.right = NewNode(8);    ``/*       /          */` `        ``root.left.right.left = NewNode(5);``/*      5           */`   `        ``Console.WriteLine(``"Level having maximum number of Nodes: "` `+ MaxNodeLevel(root));` `    ``}` `}`

Output

`Level having maximum number of Nodes : 2`

Time Complexity: O(n), where n is the number of nodes in the given tree.
Auxiliary Space: O(h), where h is the height of the tree, this space is due to the recursion call stack.

If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next