# Sum of all the levels in a Binary Search Tree

Given a Binary Search Tree, the task is to find the horizontal sum of the nodes that are at the same level.
Examples:

Input:

Output:

12
24
Input:

Output:

12
12

Approach DFS: Find the height of the given binary tree then the number of levels in the tree will be levels = height + 1. Now create an array sum[] of size levels where sum[i] will store the sum of all the nodes at the ith level. To update this array, write a recursive function that adds the current node’s data at sum[level] where the level is the level of the current node and then recursively call the same method for the child nodes with level as level + 1.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach` `#include ` `#include ` `using` `namespace` `std;`   `// A Binary Tree Node` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node *left, *right;` `};`   `// Utility function to create a new tree node` `Node* newNode(``int` `data)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->data = data;` `    ``temp->left = temp->right = NULL;` `    ``return` `temp;` `}`   `// Utility function to print` `// the contents of an array` `void` `printArr(``int` `arr[], ``int` `n)` `{` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``cout << arr[i] << endl;` `}`   `// Function to return the height` `// of the binary tree` `int` `getHeight(Node* root)` `{` `    ``if` `(root->left == NULL && root->right == NULL)` `        ``return` `0;`   `    ``int` `left = 0;` `    ``if` `(root->left != NULL)` `        ``left = getHeight(root->left);`   `    ``int` `right = 0;` `    ``if` `(root->right != NULL)` `        ``right = getHeight(root->right);`   `    ``return` `(max(left, right) + 1);` `}`   `// Recursive function to update sum[] array` `// such that sum[i] stores the sum` `// of all the elements at ith level` `void` `calculateLevelSum(Node* node, ``int` `level, ``int` `sum[])` `{` `    ``if` `(node == NULL)` `        ``return``;`   `    ``// Add current node data to the sum` `    ``// of the current node's level` `    ``sum[level] += node->data;`   `    ``// Recursive call for left and right sub-tree` `    ``calculateLevelSum(node->left, level + 1, sum);` `    ``calculateLevelSum(node->right, level + 1, sum);` `}`   `// Driver code` `int` `main()` `{` `    ``// Create the binary tree` `    ``Node* root = newNode(6);` `    ``root->left = newNode(4);` `    ``root->right = newNode(8);` `    ``root->left->left = newNode(3);` `    ``root->left->right = newNode(5);` `    ``root->right->left = newNode(7);` `    ``root->right->right = newNode(9);`   `    ``// Count of levels in the` `    ``// given binary tree` `    ``int` `levels = getHeight(root) + 1;`   `    ``// To store the sum at every level` `    ``int` `sum[levels] = { 0 };` `    ``calculateLevelSum(root, 0, sum);`   `    ``// Print the required sums` `    ``printArr(sum, levels);`   `    ``return` `0;` `}`

## Java

 `// Java implementation of the approach ` `class` `Sol` `{` `    `  `// A Binary Tree Node ` `static` `class` `Node ` `{ ` `    ``int` `data; ` `    ``Node left, right; ` `}; `   `// Utility function to create a new tree node ` `static` `Node newNode(``int` `data) ` `{ ` `    ``Node temp = ``new` `Node(); ` `    ``temp.data = data; ` `    ``temp.left = temp.right = ``null``; ` `    ``return` `temp; ` `} `   `// Utility function to print ` `// the contents of an array ` `static` `void` `printArr(``int` `arr[], ``int` `n) ` `{ ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``System.out.print(arr[i]+ ``" "` `); ` `} `   `// Function to return the height ` `// of the binary tree ` `static` `int` `getHeight(Node root) ` `{ ` `    ``if` `(root.left == ``null` `&& root.right == ``null``) ` `        ``return` `0``; `   `    ``int` `left = ``0``; ` `    ``if` `(root.left != ``null``) ` `        ``left = getHeight(root.left); `   `    ``int` `right = ``0``; ` `    ``if` `(root.right != ``null``) ` `        ``right = getHeight(root.right); `   `    ``return` `(Math.max(left, right) + ``1``); ` `} `   `// Recursive function to update sum[] array ` `// such that sum[i] stores the sum ` `// of all the elements at ith level ` `static` `void` `calculateLevelSum(Node node, ``int` `level, ``int` `sum[]) ` `{ ` `    ``if` `(node == ``null``) ` `        ``return``; `   `    ``// Add current node data to the sum ` `    ``// of the current node's level ` `    ``sum[level] += node.data; `   `    ``// Recursive call for left and right sub-tree ` `    ``calculateLevelSum(node.left, level + ``1``, sum); ` `    ``calculateLevelSum(node.right, level + ``1``, sum); ` `} `   `// Driver code ` `public` `static` `void` `main(String args[])` `{ ` `    ``// Create the binary tree ` `    ``Node root = newNode(``6``); ` `    ``root.left = newNode(``4``); ` `    ``root.right = newNode(``8``); ` `    ``root.left.left = newNode(``3``); ` `    ``root.left.right = newNode(``5``); ` `    ``root.right.left = newNode(``7``); ` `    ``root.right.right = newNode(``9``); `   `    ``// Count of levels in the ` `    ``// given binary tree ` `    ``int` `levels = getHeight(root) + ``1``; `   `    ``// To store the sum at every level ` `    ``int` `sum[]=``new` `int``[levels]; ` `    ``calculateLevelSum(root, ``0``, sum); `   `    ``// Print the required sums ` `    ``printArr(sum, levels); ` `} ` `} `   `// This code is contributed by andrew1234`

## Python3

 `# Python3 implementation of above algorithm`   `# Utility class to create a node ` `class` `Node: ` `    ``def` `__init__(``self``, key): ` `        ``self``.data ``=` `key ` `        ``self``.left ``=` `self``.right ``=` `None` `        `  `# Utility function to create a tree node` `def` `newNode( data):`   `    ``temp ``=` `Node(``0``)` `    ``temp.data ``=` `data` `    ``temp.left ``=` `temp.right ``=` `None` `    ``return` `temp`   `# Utility function to print` `# the contents of an array` `def` `printArr(arr, n):`   `    ``i ``=` `0` `    ``while` `( i < n):` `        ``print``( arr[i])` `        ``i ``=` `i ``+` `1`   `# Function to return the height` `# of the binary tree` `def` `getHeight(root):`   `    ``if` `(root.left ``=``=` `None` `and` `root.right ``=``=` `None``):` `        ``return` `0`   `    ``left ``=` `0` `    ``if` `(root.left !``=` `None``):` `        ``left ``=` `getHeight(root.left)`   `    ``right ``=` `0` `    ``if` `(root.right !``=` `None``):` `        ``right ``=` `getHeight(root.right)`   `    ``return` `(``max``(left, right) ``+` `1``)`   `sum` `=` `[]`   `# Recursive function to update sum[] array` `# such that sum[i] stores the sum` `# of all the elements at ith level` `def` `calculateLevelSum(node, level):` `    `  `    ``global` `sum` `    ``if` `(node ``=``=` `None``):` `        ``return`   `    ``# Add current node data to the sum` `    ``# of the current node's level` `    ``sum``[level] ``+``=` `node.data`   `    ``# Recursive call for left and right sub-tree` `    ``calculateLevelSum(node.left, level ``+` `1``)` `    ``calculateLevelSum(node.right, level ``+` `1``)`     `# Driver code`   `# Create the binary tree` `root ``=` `newNode(``6``)` `root.left ``=` `newNode(``4``)` `root.right ``=` `newNode(``8``)` `root.left.left ``=` `newNode(``3``)` `root.left.right ``=` `newNode(``5``)` `root.right.left ``=` `newNode(``7``)` `root.right.right ``=` `newNode(``9``)`   `# Count of levels in the` `# given binary tree` `levels ``=` `getHeight(root) ``+` `1`   `# To store the sum at every level` `sum` `=` `[``0``] ``*` `levels ` `calculateLevelSum(root, ``0``)`   `# Print the required sums` `printArr(``sum``, levels)`   `# This code is contributed by Arnab Kundu`

## C#

 `// C# implementation of the approach ` `using` `System; ` `class` `GFG ` `{ ` `    `  `// A Binary Tree Node ` `public` `class` `Node ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node left, right; ` `}; `   `// Utility function to create a new tree node ` `static` `Node newNode(``int` `data) ` `{ ` `    ``Node temp = ``new` `Node(); ` `    ``temp.data = data; ` `    ``temp.left = temp.right = ``null``; ` `    ``return` `temp; ` `} `   `// Utility function to print ` `// the contents of an array ` `static` `void` `printArr(``int` `[]arr, ``int` `n) ` `{ ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``Console.WriteLine(arr[i]); ` `} `   `// Function to return the height ` `// of the binary tree ` `static` `int` `getHeight(Node root) ` `{ ` `    ``if` `(root.left == ``null` `&& ` `        ``root.right == ``null``) ` `        ``return` `0; `   `    ``int` `left = 0; ` `    ``if` `(root.left != ``null``) ` `        ``left = getHeight(root.left); `   `    ``int` `right = 0; ` `    ``if` `(root.right != ``null``) ` `        ``right = getHeight(root.right); `   `    ``return` `(Math.Max(left, right) + 1); ` `} `   `// Recursive function to update sum[] array ` `// such that sum[i] stores the sum ` `// of all the elements at ith level ` `static` `void` `calculateLevelSum(Node node, ``int` `level, ` `                                         ``int` `[]sum) ` `{ ` `    ``if` `(node == ``null``) ` `        ``return``; `   `    ``// Add current node data to the sum ` `    ``// of the current node's level ` `    ``sum[level] += node.data; `   `    ``// Recursive call for left and right sub-tree ` `    ``calculateLevelSum(node.left, level + 1, sum); ` `    ``calculateLevelSum(node.right, level + 1, sum); ` `} `   `// Driver code ` `public` `static` `void` `Main(String []args) ` `{ ` `    ``// Create the binary tree ` `    ``Node root = newNode(6); ` `    ``root.left = newNode(4); ` `    ``root.right = newNode(8); ` `    ``root.left.left = newNode(3); ` `    ``root.left.right = newNode(5); ` `    ``root.right.left = newNode(7); ` `    ``root.right.right = newNode(9); `   `    ``// Count of levels in the ` `    ``// given binary tree ` `    ``int` `levels = getHeight(root) + 1; `   `    ``// To store the sum at every level ` `    ``int` `[]sum = ``new` `int``[levels]; ` `    ``calculateLevelSum(root, 0, sum); `   `    ``// Print the required sums ` `    ``printArr(sum, levels); ` `} ` `} `   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

```6
12
24```

Time Complexity : O(N)
Auxiliary Space: O(N)

Approach BFS:-Find the height of the given binary tree then the number of levels in the tree will level = height + 1. Now create an array sum[] of size levels where sum[i] will store the sum of all the nodes at the ith level. To update this array Using Breadth-First Search We Will calculate the sum at That Level with Queue and Add their children for future Levels

## C++

 `#include` `using` `namespace` `std;`   `// A Binary Tree Node` `struct` `Node {` `    ``int` `data;` `    ``Node *left, *right;` `    ``Node(``int` `data)` `    ``{` `        ``this``->data = data;` `        ``left = right = NULL;` `    ``}` `};`   `// Utility function to print` `// the contents of an array` `void` `printArr(``int` `arr[], ``int` `n)` `{` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``cout << arr[i] << ``" "``;` `}`   `// Function to return the height` `// of the binary tree` `int` `getHeight(Node *root)` `{` `    ``if` `(root == NULL)` `        ``return` `0;`   `    ``int` `left = 0;` `    ``if` `(root->left != NULL)` `        ``left = getHeight(root->left);`   `    ``int` `right = 0;` `    ``if` `(root->right != NULL)` `        ``right = getHeight(root->right);`   `    ``return` `(max(left, right) + 1);` `}`   `// Function to Calculate Level Sum Using BFS` `void` `calculateLevelSum_Using_BFS(Node *root, ``int` `sum[])` `{` `    ``// Queue Through Which We Will Travel Tree Level` `    ``// Wise` `    ``queue q;`   `    ``// Stores The CurrentLevel for Which is` `    ``// Calculating Sum` `    ``int` `current_level = 0;`   `    ``// Add root Node to queue` `    ``q.push(root);`   `    ``// Travel queue` `    ``while` `(!q.empty()) {`   `        ``// Stores the No. of Nodes at Current Level` `        ``int` `no_of_nodes_current_level = q.size();` `        ``// Will store the LevelSum of CurrentLevel` `        ``int` `current_LevelSum = 0;`   `        ``// Traveling all node of current level` `        ``for` `(``int` `i = 0; i < no_of_nodes_current_level; i++) {` `            ``Node *``remove` `= q.front();` `            ``q.pop();` `            ``current_LevelSum += ``remove``->data;`   `            ``// Adding left node of next level if exist` `            ``if` `(``remove``->left != NULL) {` `                ``q.push(``remove``->left);` `            ``}` `            ``// Adding right node of next level if exist` `            ``if` `(``remove``->right != NULL) {` `                ``q.push(``remove``->right);` `            ``}` `        ``}` `        ``// Assign Value of current Level Sum to Sum` `        ``// arr` `        ``sum[current_level] = current_LevelSum;`   `        ``// Increasing Level for next Iteration` `        ``current_level++;` `    ``}` `}` `int` `main()` `{` `    ``// Creating Tree` `    ``Node *root = ``new` `Node(6);` `    ``root->left = ``new` `Node(4);` `    ``root->right = ``new` `Node(8);` `    ``root->left->left = ``new` `Node(3);` `    ``root->left->right = ``new` `Node(5);` `    ``root->right->left = ``new` `Node(7);` `    ``root->right->right = ``new` `Node(9);`   `    ``// Finding How Many Level Does The Tree Have` `    ``int` `levels = getHeight(root);` `    ``int` `sum[levels];`   `    ``// Calling The Function` `    ``calculateLevelSum_Using_BFS(root, sum);`   `    ``// Printing the Array` `    ``printArr(sum, levels);`   `    ``return` `0;` `}`

## Java

 `/*package whatever //do not write package name here */`   `import` `java.io.*;` `import` `java.util.LinkedList;` `import` `java.util.Queue;`   `// A Binary Tree Node` `class` `Node {` `    ``int` `data;` `    ``Node left, right;` `    ``Node(``int` `data)` `    ``{` `        ``this``.data = data;` `        ``left = ``null``;` `        ``right = ``null``;` `    ``}` `}` `public` `class` `GFG {`   `    ``// Utility function to create a new tree node` `    ``static` `Node newNode(``int` `data)` `    ``{` `        ``Node temp = ``new` `Node(data);` `        ``temp.data = data;` `        ``temp.left = temp.right = ``null``;` `        ``return` `temp;` `    ``}`   `    ``// Utility function to print` `    ``// the contents of an array` `    ``static` `void` `printArr(``int` `arr[], ``int` `n)` `    ``{` `        ``for` `(``int` `i = ``0``; i < n; i++)` `            ``System.out.print(arr[i] + ``" "``);` `    ``}`   `    ``// Function to return the height` `    ``// of the binary tree` `    ``static` `int` `getHeight(Node root)` `    ``{` `        ``if` `(root.left == ``null` `&& root.right == ``null``)` `            ``return` `0``;`   `        ``int` `left = ``0``;` `        ``if` `(root.left != ``null``)` `            ``left = getHeight(root.left);`   `        ``int` `right = ``0``;` `        ``if` `(root.right != ``null``)` `            ``right = getHeight(root.right);`   `        ``return` `(Math.max(left, right) + ``1``);` `    ``}`   `    ``// Function to Calculate Level Sum Using BFS` `    ``static` `void` `calculateLevelSum_Using_BFS(Node root,` `                                            ``int` `sum[])` `    ``{` `        ``// Queue Through Which We Will Travel Tree Level` `        ``// Wise` `        ``Queue queue = ``new` `LinkedList<>();`   `        ``// Stores The CurrentLevel for Which is` `        ``// Calculating Sum` `        ``int` `cureentlevel = ``0``;`   `        ``// Add root Node to queue` `        ``queue.add(root);`   `        ``// Travel queue` `        ``while` `(queue.size() > ``0``) {`   `            ``// Stores the No. of Nodes at Current Level` `            ``int` `no_of_nodes_current_Level = queue.size();` `            ``// Will store the LevelSum of CurrentLevel` `            ``int` `current_LevelSum = ``0``;`   `            ``// Traveling all node of current level` `            ``for` `(``int` `i = ``0``; i < no_of_nodes_current_Level;` `                 ``i++) {` `                ``Node remove = queue.poll();` `                ``current_LevelSum += remove.data;`   `                ``// Adding left node of next level if exist` `                ``if` `(remove.left != ``null``) {` `                    ``queue.add(remove.left);` `                ``}` `                ``// Adding right node of next level if exist` `                ``if` `(remove.right != ``null``) {` `                    ``queue.add(remove.right);` `                ``}` `            ``}` `            ``// Assig Value of current Level Sum to Sum` `            ``// arr` `            ``sum[cureentlevel] = current_LevelSum;`   `            ``// Increasing Level for next Iteration` `            ``cureentlevel++;` `        ``}` `    ``}` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Creating Tree` `        ``Node root = newNode(``6``);` `        ``root.left = newNode(``4``);` `        ``root.right = newNode(``8``);` `        ``root.left.left = newNode(``3``);` `        ``root.left.right = newNode(``5``);` `        ``root.right.left = newNode(``7``);` `        ``root.right.right = newNode(``9``);` `        ``// Finding How Many Level Does The Tree Have` `        ``int` `levels = getHeight(root) + ``1``;` `        ``int` `sum[] = ``new` `int``[levels];` `        ``// Calling The Function` `        ``calculateLevelSum_Using_BFS(root, sum);` `        ``// Printing the Array` `        ``printArr(sum, levels);` `    ``}` `    ``// This Code is Contributed By Vikas Bishnoi` `}`

## Python3

 `#Node constructor` `class` `Node:` `    ``def` `__init__(``self``, key):` `        ``self``.data ``=` `key` `        ``self``.left ``=` `self``.right ``=` `None` `         `  `# Utility function to create a tree node` `def` `newNode( data):` `    ``temp ``=` `Node(``0``)` `    ``temp.data ``=` `data` `    ``temp.left ``=` `temp.right ``=` `None` `    ``return` `temp` `#function to print output array` `def` `printArr(arr, n):` `    ``i ``=` `0` `    ``while` `( i < n):` `        ``print``( arr[i])` `        ``i ``=` `i ``+` `1`   `#function to get height at that particular level`   `def` `getHeight(root):` ` `  `    ``if` `(root.left ``=``=` `None` `and` `root.right ``=``=` `None``):` `        ``return` `0` ` `  `    ``left ``=` `0` `    ``if` `(root.left !``=` `None``):` `        ``left ``=` `getHeight(root.left)` ` `  `    ``right ``=` `0` `    ``if` `(root.right !``=` `None``):` `        ``right ``=` `getHeight(root.right)` ` `  `    ``return` `(``max``(left, right) ``+` `1``)`   `def` `calculateLevelSum_Using_BFS(root, ``sum``):` `    ``# Queue Through Which We Will Travel Tree Level` `    ``# Wise` `    ``queue ``=` `[]` `# Stores The CurrentLevel for Which is` `# Calculating Sum` `    ``cureentlevel ``=` `0`   `# Add root Node to queue` `    ``queue.append(root)`   `    ``while` `len``(queue) > ``0``:` `        ``# Stores the No. of Nodes at Current Level` `        ``no_of_nodes_current_Level ``=` `len``(queue)` `        ``# Will store the LevelSum of CurrentLevel` `        ``current_LevelSum ``=` `0`   `        ``# Traveling all node of current level` `        ``for` `i ``in` `range``(no_of_nodes_current_Level):` `            ``remove ``=` `queue.pop(``0``)` `            ``current_LevelSum ``+``=` `remove.data`   `            ``# Adding left node of next level if exist` `            ``if` `remove.left ``is` `not` `None``:` `                ``queue.append(remove.left)` `            ``# Adding right node of next level if exist` `            ``if` `remove.right ``is` `not` `None``:` `                ``queue.append(remove.right)`   `        ``# Assigning Value of current Level Sum to Sum` `        ``# arr` `        ``sum``[cureentlevel] ``=` `current_LevelSum`   `        ``# Increasing Level for next Iteration` `        ``cureentlevel ``+``=` `1`   `    ``# Creating Tree` `root ``=` `newNode(``6``)` `root.left ``=` `newNode(``4``)` `root.right ``=` `newNode(``8``)` `root.left.left ``=` `newNode(``3``)` `root.left.right ``=` `newNode(``5``)` `root.right.left ``=` `newNode(``7``)` `root.right.right ``=` `newNode(``9``)` `# Finding How Many Level Does The Tree Have` `levels ``=` `getHeight(root) ``+` `1` `sum` `=` `[``0``] ``*` `levels` `# Calling The Function` `calculateLevelSum_Using_BFS(root, ``sum``)` `# Printing the Array` `printArr(``sum``, levels)`       `#This code is contributed by Tejas Gundale`

## Javascript

 `// A Binary Tree Node` `class Node {` `  ``constructor(data) {` `    ``this``.data = data;` `    ``this``.left = ``null``;` `    ``this``.right = ``null``;` `  ``}` `}`   `// Utility function to print the contents of an array` `function` `printArr(arr, n) {` `  ``for` `(let i = 0; i < n; i++) {` `    ``console.log(arr[i] + ``" "``);` `  ``}` `}`   `// Function to return the height of the binary tree` `function` `getHeight(root) {` `  ``if` `(root == ``null``) {` `    ``return` `0;` `  ``}`   `  ``let left = 0;` `  ``if` `(root.left != ``null``) {` `    ``left = getHeight(root.left);` `  ``}`   `  ``let right = 0;` `  ``if` `(root.right != ``null``) {` `    ``right = getHeight(root.right);` `  ``}`   `  ``return` `Math.max(left, right) + 1;` `}`   `// Function to Calculate Level Sum Using BFS` `function` `calculateLevelSum_Using_BFS(root, sum) {` `  ``// Queue Through Which We Will Travel Tree Level Wise` `  ``let q = [];`   `  ``// Stores The CurrentLevel for Which is Calculating Sum` `  ``let currentLevel = 0;`   `  ``// Add root Node to queue` `  ``q.push(root);`   `  ``// Travel queue` `  ``while` `(q.length > 0) {` `    ``// Stores the No. of Nodes at Current Level` `    ``let noOfNodesCurrentLevel = q.length;`   `    ``// Will store the LevelSum of CurrentLevel` `    ``let currentLevelSum = 0;`   `    ``// Traveling all node of current level` `    ``for` `(let i = 0; i < noOfNodesCurrentLevel; i++) {` `      ``let remove = q.shift();` `      ``currentLevelSum += remove.data;`   `      ``// Adding left node of next level if exist` `      ``if` `(remove.left != ``null``) {` `        ``q.push(remove.left);` `      ``}` `      ``// Adding right node of next level if exist` `      ``if` `(remove.right != ``null``) {` `        ``q.push(remove.right);` `      ``}` `    ``}` `    ``// Assign Value of current Level Sum to Sum arr` `    ``sum[currentLevel] = currentLevelSum;`   `    ``// Increasing Level for next Iteration` `    ``currentLevel++;` `  ``}` `}`   `// driver program to test above functions` `// Creating Tree` `let root = ``new` `Node(6);` `root.left = ``new` `Node(4);` `root.right = ``new` `Node(8);` `root.left.left = ``new` `Node(3);` `root.left.right = ``new` `Node(5);` `root.right.left = ``new` `Node(7);` `root.right.right = ``new` `Node(9);`   `// Finding How Many Level Does The Tree Have` `let levels = getHeight(root);` `let sum = ``new` `Array(levels);`   `// Calling The Function` `calculateLevelSum_Using_BFS(root, sum);`   `// Printing the Array` `printArr(sum, levels);`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `// A Binary Tree Node` `class` `Node` `{` `public` `int` `data;` `public` `Node left, right;` `public` `Node(``int` `data)` `{` `this``.data = data;` `left = ``null``;` `right = ``null``;` `}` `}`   `public` `class` `GFG` `{` `// Utility function to create a new tree node` `static` `Node newNode(``int` `data)` `{` `Node temp = ``new` `Node(data);` `temp.data = data;` `temp.left = temp.right = ``null``;` `return` `temp;` `}` `  ``// Utility function to print` `// the contents of an array` `static` `void` `printArr(``int``[] arr, ``int` `n)` `{` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``Console.Write(arr[i] + ``" "``);` `}`   `// Function to return the height` `// of the binary tree` `static` `int` `getHeight(Node root)` `{` `    ``if` `(root.left == ``null` `&& root.right == ``null``)` `        ``return` `0;`   `    ``int` `left = 0;` `    ``if` `(root.left != ``null``)` `        ``left = getHeight(root.left);`   `    ``int` `right = 0;` `    ``if` `(root.right != ``null``)` `        ``right = getHeight(root.right);`   `    ``return` `(Math.Max(left, right) + 1);` `}`   `// Function to Calculate Level Sum Using BFS` `static` `void` `calculateLevelSum_Using_BFS(Node root, ``int``[] sum)` `{` `    ``// Queue Through Which We Will Travel Tree Level` `    ``// Wise` `    ``Queue queue = ``new` `Queue();`   `    ``// Stores The CurrentLevel for Which is` `    ``// Calculating Sum` `    ``int` `currentLevel = 0;`   `    ``// Add root Node to queue` `    ``queue.Enqueue(root);`   `    ``// Travel queue` `    ``while` `(queue.Count > 0)` `    ``{`   `        ``// Stores the No. of Nodes at Current Level` `        ``int` `no_of_nodes_current_Level = queue.Count;` `        ``// Will store the LevelSum of CurrentLevel` `        ``int` `current_LevelSum = 0;`   `        ``// Traveling all node of current level` `        ``for` `(``int` `i = 0; i < no_of_nodes_current_Level; i++)` `        ``{` `            ``Node remove = queue.Dequeue();` `            ``current_LevelSum += remove.data;`   `            ``// Adding left node of next level if exist` `            ``if` `(remove.left != ``null``)` `            ``{` `                ``queue.Enqueue(remove.left);` `            ``}` `            ``// Adding right node of next level if exist` `            ``if` `(remove.right != ``null``)` `            ``{` `                ``queue.Enqueue(remove.right);` `            ``}` `        ``}` `        ``// Assig Value of current Level Sum to Sum` `        ``// arr` `        ``sum[currentLevel] = current_LevelSum;`   `        ``// Increasing Level for next Iteration` `        ``currentLevel++;` `    ``}` `}` `public` `static` `void` `Main(``string``[] args)` `{` `    ``// Creating Tree` `    ``Node root = newNode(6);` `    ``root.left = newNode(4);` `    ``root.right = newNode(8);` `    ``root.left.left = newNode(3);` `    ``root.left.right = newNode(5);` `    ``root.right.left = newNode(7);` `    ``root.right.right = newNode(9);`   `    ``// Finding How Many Level Does The Tree Have` `    ``int` `levels = getHeight(root) + 1;` `    ``int``[] sum = ``new` `int``[levels];`   `    ``// Calling The Function` `    ``calculateLevelSum_Using_BFS(root, sum);`   `    ``// Printing the Array` `    ``printArr(sum, levels);` `}` `// This Code is Contributed By Vikas Bishnoi` `}`

Output

`6 12 24 `

Time Complexity: O(N) Where is the number of Nodes in a tree. As Each Node is only Visited Once so Complexity is O(N)
Auxiliary Space: O(N) Used In queue to store nodes

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