# Diagonal Sum of a Binary Tree

Consider lines of slope -1 passing between nodes (dotted lines in below diagram). The diagonal sum in a binary tree is the sum of all node’s data lying between these lines. Given a Binary Tree, print all diagonal sums.

```For the following input tree, the output should be 9, 19, 42.
9 is sum of 1, 3 and 5.
19 is sum of 2, 6, 4 and 7.
42 is sum of 9, 10, 11 and 12.```

Recommended Practice

Algorithm:

The idea is to keep track of vertical distance from top diagonal passing through the root. We increment the vertical distance we go down to next diagonal.

1. Add root with vertical distance as 0 to the queue.
2. Process the sum of all right child and right of the right child and so on.
3. Add left child current node into the queue for later processing. The vertical distance of the left child is the vertical distance of current node plus 1.
4. Keep doing 2nd, 3rd and 4th step till the queue is empty.

Following is the implementation of the above idea.

## C++

 `// C++ Program to find diagonal` `// sum in a Binary Tree` `#include ` `using` `namespace` `std;`   `struct` `Node` `{` `    ``int` `data;` `    ``struct` `Node* left;` `    ``struct` `Node* right;` `};`   `struct` `Node* newNode(``int` `data)` `{` `    ``struct` `Node* Node =` `            ``(``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));` `    `  `    ``Node->data = data;` `    ``Node->left = Node->right = NULL;`   `    ``return` `Node;` `}`   `// root - root of the binary tree` `// vd - vertical distance diagonally` `// diagonalSum - map to store Diagonal ` `// Sum(Passed by Reference)` `void` `diagonalSumUtil(``struct` `Node* root,` `                ``int` `vd, map<``int``, ``int``> &diagonalSum)` `{` `    ``if``(!root)` `        ``return``;` `        `  `    ``diagonalSum[vd] += root->data;`   `    ``// increase the vertical distance if left child` `    ``diagonalSumUtil(root->left, vd + 1, diagonalSum);`   `    ``// vertical distance remains same for right child` `    ``diagonalSumUtil(root->right, vd, diagonalSum);` `}`   `// Function to calculate diagonal ` `// sum of given binary tree` `void` `diagonalSum(``struct` `Node* root)` `{`   `    ``// create a map to store Diagonal Sum` `    ``map<``int``, ``int``> diagonalSum; ` `    `  `    ``diagonalSumUtil(root, 0, diagonalSum);`   `    ``map<``int``, ``int``>::iterator it;` `        ``cout << ``"Diagonal sum in a binary tree is - "``;` `    `  `    ``for``(it = diagonalSum.begin();` `                ``it != diagonalSum.end(); ++it)` `    ``{` `        ``cout << it->second << ``" "``;` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``struct` `Node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->left->left = newNode(9);` `    ``root->left->right = newNode(6);` `    ``root->right->left = newNode(4);` `    ``root->right->right = newNode(5);` `    ``root->right->left->right = newNode(7);` `    ``root->right->left->left = newNode(12);` `    ``root->left->right->left = newNode(11);` `    ``root->left->left->right = newNode(10);`   `    ``diagonalSum(root);`   `    ``return` `0;` `}`   `// This code is contributed by Aditya Goel`

## Java

 `// Java Program to find diagonal sum in a Binary Tree` `import` `java.util.*;` `import` `java.util.Map.Entry;`   `//Tree node` `class` `TreeNode` `{` `    ``int` `data; ``//node data` `    ``int` `vd; ``//vertical distance diagonally` `    ``TreeNode left, right; ``//left and right child's reference`   `    ``// Tree node constructor` `    ``public` `TreeNode(``int` `data)` `    ``{` `        ``this``.data = data;` `        ``vd = Integer.MAX_VALUE;` `        ``left = right = ``null``;` `    ``}` `}`   `// Tree class` `class` `Tree` `{` `    ``TreeNode root;``//Tree root`   `    ``// Tree constructor` `    ``public` `Tree(TreeNode root)  {  ``this``.root = root;  }`   `    ``// Diagonal sum method` `    ``public` `void` `diagonalSum()` `    ``{` `        ``// Queue which stores tree nodes` `        ``Queue queue = ``new` `LinkedList();`   `        ``// Map to store sum of node's data lying diagonally` `        ``Map map = ``new` `TreeMap<>();`   `        ``// Assign the root's vertical distance as 0.` `        ``root.vd = ``0``;`   `        ``// Add root node to the queue` `        ``queue.add(root);`   `        ``// Loop while the queue is not empty` `        ``while` `(!queue.isEmpty())` `        ``{` `            ``// Remove the front tree node from queue.` `            ``TreeNode curr = queue.remove();`   `            ``// Get the vertical distance of the dequeued node.` `            ``int` `vd = curr.vd;`   `            ``// Sum over this node's right-child, right-of-right-child` `            ``// and so on` `            ``while` `(curr != ``null``)` `            ``{` `                ``int` `prevSum = (map.get(vd) == ``null``)? ``0``: map.get(vd);` `                ``map.put(vd, prevSum + curr.data);`   `                ``// If for any node the left child is not null add` `                ``// it to the queue for future processing.` `                ``if` `(curr.left != ``null``)` `                ``{` `                    ``curr.left.vd = vd+``1``;` `                    ``queue.add(curr.left);` `                ``}`   `                ``// Move to the current node's right child.` `                ``curr = curr.right;` `            ``}` `        ``}`   `        ``// Make an entry set from map.` `        ``Set> set = map.entrySet();`   `        ``// Make an iterator` `        ``Iterator> iterator = set.iterator();`   `        ``// Traverse the map elements using the iterator.` `         ``System.out.print(``"Diagonal sum in a binary tree is - "``);` `        ``while` `(iterator.hasNext())` `        ``{` `            ``Map.Entry me = iterator.next();`   `            ``System.out.print(me.getValue()+``" "``);` `        ``}` `    ``}` `}`   `//Driver class` `public` `class` `DiagonalSum` `{` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``TreeNode root = ``new` `TreeNode(``1``);` `        ``root.left = ``new` `TreeNode(``2``);` `        ``root.right = ``new` `TreeNode(``3``);` `        ``root.left.left = ``new` `TreeNode(``9``);` `        ``root.left.right = ``new` `TreeNode(``6``);` `        ``root.right.left = ``new` `TreeNode(``4``);` `        ``root.right.right = ``new` `TreeNode(``5``);` `        ``root.right.left.left = ``new` `TreeNode(``12``);` `        ``root.right.left.right = ``new` `TreeNode(``7``);` `        ``root.left.right.left = ``new` `TreeNode(``11``);` `        ``root.left.left.right = ``new` `TreeNode(``10``);` `        ``Tree tree = ``new` `Tree(root);` `        ``tree.diagonalSum();` `    ``}` `}`

## Python3

 `# Program to find diagonal sum in a Binary Tree`   `class` `newNode: ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data ` `        ``self``.left ``=` `self``.right ``=` `None` `        `  `# Function to compute height and ` `# root - root of the binary tree ` `# vd - vertical distance diagonally ` `# diagonalSum - map to store Diagonal ` `# Sum(Passed by Reference) ` `def` `diagonalSumUtil(root, vd, diagonalSum) :`   `    ``if``(``not` `root): ` `        ``return` `        `  `    ``if` `vd ``not` `in` `diagonalSum:` `        ``diagonalSum[vd] ``=` `0` `    ``diagonalSum[vd] ``+``=` `root.data `   `    ``# increase the vertical distance` `    ``# if left child ` `    ``diagonalSumUtil(root.left, vd ``+` `1``, ` `                          ``diagonalSum) `   `    ``# vertical distance remains same ` `    ``# for right child ` `    ``diagonalSumUtil(root.right, vd,` `                       ``diagonalSum) `   `# Function to calculate diagonal ` `# sum of given binary tree ` `def` `diagonalSum(root) :`   `    ``# create a map to store Diagonal Sum ` `    ``diagonalSum ``=` `dict``() ` `    `  `    ``diagonalSumUtil(root, ``0``, diagonalSum) `   `    ``print``(``"Diagonal sum in a binary tree is - "``, ` `                                       ``end ``=` `"")` `    `  `    ``for` `it ``in` `diagonalSum:` `        ``print``(diagonalSum[it], end ``=` `" "``)` `        `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``:` `    ``root ``=` `newNode(``1``) ` `    ``root.left ``=` `newNode(``2``) ` `    ``root.right ``=` `newNode(``3``) ` `    ``root.left.left ``=` `newNode(``9``) ` `    ``root.left.right ``=` `newNode(``6``) ` `    ``root.right.left ``=` `newNode(``4``) ` `    ``root.right.right ``=` `newNode(``5``) ` `    ``root.right.left.right ``=` `newNode(``7``) ` `    ``root.right.left.left ``=` `newNode(``12``) ` `    ``root.left.right.left ``=` `newNode(``11``) ` `    ``root.left.left.right ``=` `newNode(``10``) `   `    ``diagonalSum(root)`   `# This code is contributed ` `# by SHUBHAMSINGH10`

## C#

 `// C# Program to find diagonal sum in a Binary Tree` `using` `System;` `using` `System.Collections.Generic;`   `// Tree node` `public`   `  ``class` `TreeNode` `  ``{` `    ``public` `      ``int` `data; ``// node data` `    ``public`   `      ``int` `vd; ``// vertical distance diagonally` `    ``public` `      ``TreeNode left, right; ``// left and right child's reference`   `    ``// Tree node constructor` `    ``public` `TreeNode(``int` `data)` `    ``{` `      ``this``.data = data;` `      ``vd = ``int``.MaxValue;` `      ``left = right = ``null``;` `    ``}` `  ``}`   `// Tree class` `public` `class` `Tree` `{` `  ``TreeNode root;``//T ree root`   `  ``// Tree constructor` `  ``public` `Tree(TreeNode root)` `  ``{` `    ``this``.root = root;` `  ``}`   `  ``// Diagonal sum method` `  ``public` `void` `diagonalSum()` `  ``{`   `    ``// Queue which stores tree nodes` `    ``Queue queue = ``new` `Queue();`   `    ``// Map to store sum of node's data lying diagonally` `    ``Dictionary<``int``, ``int``> map = ``new` `Dictionary<``int``,``int``>();`   `    ``// Assign the root's vertical distance as 0.` `    ``root.vd = 0;`   `    ``// Add root node to the queue` `    ``queue.Enqueue(root);`   `    ``// Loop while the queue is not empty` `    ``while` `(queue.Count != 0)` `    ``{`   `      ``// Remove the front tree node from queue.` `      ``TreeNode curr = queue.Dequeue();`   `      ``// Get the vertical distance of the dequeued node.` `      ``int` `vd = curr.vd;`   `      ``// Sum over this node's right-child, right-of-right-child` `      ``// and so on` `      ``while` `(curr != ``null``)` `      ``{` `        ``int` `prevSum;` `        ``if``(!map.ContainsKey(vd))` `          ``prevSum = 0;` `        ``else` `          ``prevSum =  map[vd];`   `        ``if``(map.ContainsKey(vd))` `          ``map[vd] =  prevSum + curr.data;` `        ``else` `          ``map.Add(vd, prevSum + curr.data);`   `        ``// If for any node the left child is not null add` `        ``// it to the queue for future processing.` `        ``if` `(curr.left != ``null``)` `        ``{` `          ``curr.left.vd = vd + 1;` `          ``queue.Enqueue(curr.left);` `        ``}`   `        ``// Move to the current node's right child.` `        ``curr = curr.right;` `      ``}` `    ``}`     `    ``// Traverse the map elements using the iterator.` `    ``Console.Write(``"Diagonal sum in a binary tree is - "``);` `    ``foreach``(KeyValuePair<``int``, ``int``> iterator ``in` `map)` `    ``{`   `      ``//  Map.Entry me = iterator.next();` `      ``Console.Write(iterator.Value + ``" "``);` `    ``}` `  ``}` `}`   `// Driver class` `public` `class` `DiagonalSum` `{` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``TreeNode root = ``new` `TreeNode(1);` `    ``root.left = ``new` `TreeNode(2);` `    ``root.right = ``new` `TreeNode(3);` `    ``root.left.left = ``new` `TreeNode(9);` `    ``root.left.right = ``new` `TreeNode(6);` `    ``root.right.left = ``new` `TreeNode(4);` `    ``root.right.right = ``new` `TreeNode(5);` `    ``root.right.left.left = ``new` `TreeNode(12);` `    ``root.right.left.right = ``new` `TreeNode(7);` `    ``root.left.right.left = ``new` `TreeNode(11);` `    ``root.left.left.right = ``new` `TreeNode(10);` `    ``Tree tree = ``new` `Tree(root);` `    ``tree.diagonalSum();` `  ``}` `}`   `// This code is contributed by gauravrajput1 `

## Javascript

 ``

Output

`Diagonal sum in a binary tree is - 9 19 42 `

Time Complexity: O(n)

As every node is visited just once.

Auxiliary Space: O(h+d)

Here h is the height of the tree and d is the number of diagonals. The extra space is required for recursion call stack and to store the diagonal sum in the map. In the worst case(left skewed tree) this can go upto O(n).

Exercise:
This problem was for diagonals from top to bottom and slope -1. Try the same problem for slope +1.

### Method 2:

The idea behind this method is inspired by the diagonal relation in matrices. We can observe that all the elements lying on the same diagonal in a matrix have their difference of row and column same. For instance, consider the main diagonal in a square matrix, we can observe the difference of the respective row and column indices of each element on diagonal is same, i.e. each element on the main diagonal have the difference of row and column 0, eg: 0-0, 1-1, 2-2,…n-n.

Similarly, every diagonal has its own unique difference of rows and column, and with the help of this, we can identify each element, that to which diagonal it belongs.

The same idea is applied to solve this problem-

• We will treat the level of the tree nodes as their row indices, and width of the tree nodes as their column indices.
• We will denote the cell of each node as (level, width)

Example- (Taking the same tree as above)

To help you visualize let’s draw a matrix, the first row and first column, are respective width and level indices-

Below is the implementation of the above idea:

## C++

 `// C++ Program to calculate the` `// sum of diagonal nodes.`   `#include ` `using` `namespace` `std;`   `// Node Structure` `struct` `Node {` `    ``int` `data;` `    ``Node *left, *right;` `};`   `// to map the node with level - index` `map<``int``, ``int``> grid;`   `// Function to create new node` `struct` `Node* newNode(``int` `data)` `{` `    ``struct` `Node* Node` `        ``= (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));`   `    ``Node->data = data;` `    ``Node->left = Node->right = NULL;`   `    ``return` `Node;` `}`   `// recursvise function to calculate sum of elements` `// where level - index is same.` `void` `addConsideringGrid(Node* root, ``int` `level, ``int` `index)` `{`   `    ``// if there is no child then return` `    ``if` `(root == NULL)` `        ``return``;`   `    ``// add the element in the group of node` `    ``// whose level - index is equal` `    ``grid[level - index] += (root->data);`   `    ``// left child call` `    ``addConsideringGrid(root->left, level + 1, index - 1);`   `    ``// right child call` `    ``addConsideringGrid(root->right, level + 1, index + 1);` `}`   `vector<``int``> diagonalSum(Node* root)` `{` `    ``grid.clear();`   `    ``// Function call` `    ``addConsideringGrid(root, 0, 0);` `    ``vector<``int``> ans;`   `    ``// for different values of level - index` `    ``// add te sum of those node to answer` `    ``for` `(``auto` `x : grid) {` `        ``ans.push_back(x.second);` `    ``}`   `    ``return` `ans;` `}`   `// Driver code` `int` `main()` `{`   `    ``// build binary tree` `    ``struct` `Node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->left->left = newNode(9);` `    ``root->left->right = newNode(6);` `    ``root->right->left = newNode(4);` `    ``root->right->right = newNode(5);` `    ``root->right->left->right = newNode(7);` `    ``root->right->left->left = newNode(12);` `    ``root->left->right->left = newNode(11);` `    ``root->left->left->right = newNode(10);`   `    ``// Function Call` `    ``vector<``int``> v = diagonalSum(root);`   `    ``// print the diagonal sums` `    ``for` `(``int` `i = 0; i < v.size(); i++)` `        ``cout << v[i] << ``" "``;` `      ``return` `0;` `}`

## Java

 `// Java Program to calculate the` `// sum of diagonal nodes.` `import` `java.util.*;` `class` `GFG` `{`   `// Node Structure` `static` `class` `Node` `{` `    ``int` `data;` `    ``Node left, right;` `};`   `// to map the node with level - index` `static` `HashMap grid = ``new` `HashMap<>();`   `// Function to create new node` `static` `Node newNode(``int` `data)` `{` `    ``Node Node = ``new` `Node();` `    ``Node.data = data;` `    ``Node.left = Node.right = ``null``;` `    ``return` `Node;` `}`   `// recursvise function to calculate sum of elements` `// where level - index is same.` `static` `void` `addConsideringGrid(Node root, ``int` `level, ``int` `index)` `{`   `    ``// if there is no child then return` `    ``if` `(root == ``null``)` `        ``return``;`   `    ``// add the element in the group of node` `    ``// whose level - index is equal` `    ``if``(grid.containsKey(level-index))` `    ``grid.put(level - index,grid.get(level-index) + (root.data));` `    ``else` `        ``grid.put(level-index, root.data);`   `    ``// left child call` `    ``addConsideringGrid(root.left, level + ``1``, index - ``1``);`   `    ``// right child call` `    ``addConsideringGrid(root.right, level + ``1``, index + ``1``);` `}`   `static` `Vector diagonalSum(Node root)` `{` `    ``grid.clear();`   `    ``// Function call` `    ``addConsideringGrid(root, ``0``, ``0``);` `    ``Vector ans = ``new` `Vector<>();`   `    ``// for different values of level - index` `    ``// add te sum of those node to answer` `    ``for` `(Map.Entry x : grid.entrySet()) ` `    ``{` `        ``ans.add(x.getValue());` `    ``}` `    ``return` `ans;` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{`   `    ``// build binary tree` `    ``Node root = newNode(``1``);` `    ``root.left = newNode(``2``);` `    ``root.right = newNode(``3``);` `    ``root.left.left = newNode(``9``);` `    ``root.left.right = newNode(``6``);` `    ``root.right.left = newNode(``4``);` `    ``root.right.right = newNode(``5``);` `    ``root.right.left.right = newNode(``7``);` `    ``root.right.left.left = newNode(``12``);` `    ``root.left.right.left = newNode(``11``);` `    ``root.left.left.right = newNode(``10``);`   `    ``// Function Call` `    ``Vector v = diagonalSum(root);`   `    ``// print the diagonal sums` `    ``for` `(``int` `i = ``0``; i < v.size(); i++)` `        ``System.out.print(v.get(i) + ``" "``);` `  ``}` `}`   `// This code is contributed by Rajput-Ji .`

## Python3

 `# Python3 program calculate the` `# sum of diagonal nodes.` `from` `collections ``import` `deque`   `# A binary tree node structure` `class` `Node:` `    ``def` `__init__(``self``, key):` `        `  `        ``self``.data ``=` `key` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# To map the node with level - index` `grid ``=` `{}`   `# Recursvise function to calculate ` `# sum of elements where level - index` `# is same` `def` `addConsideringGrid(root, level, index):` `    `  `    ``global` `grid`   `    ``# If there is no child then return` `    ``if` `(root ``=``=` `None``):` `        ``return`   `    ``# Add the element in the group of node` `    ``# whose level - index is equal` `    ``grid[level ``-` `index] ``=` `(grid.get(level ``-` `index, ``0``) ``+` `                           ``root.data)`   `    ``# Left child call` `    ``addConsideringGrid(root.left, level ``+` `1``,` `                                  ``index ``-` `1``)`   `    ``# Right child call` `    ``addConsideringGrid(root.right, level ``+` `1``, ` `                                   ``index ``+` `1``)`   `def` `diagonalSum(root):` `    `  `    ``# grid.clear()`   `    ``# Function call` `    ``addConsideringGrid(root, ``0``, ``0``)` `    ``ans ``=` `[]`   `    ``# For different values of level - index` `    ``# add te sum of those node to answer` `    ``for` `x ``in` `grid:` `        ``ans.append(grid[x])`   `    ``return` `ans`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Build binary tree` `    ``root ``=` `Node(``1``)` `    ``root.left ``=` `Node(``2``)` `    ``root.right ``=` `Node(``3``)` `    ``root.left.left ``=` `Node(``9``)` `    ``root.left.right ``=` `Node(``6``)` `    ``root.right.left ``=` `Node(``4``)` `    ``root.right.right ``=` `Node(``5``)` `    ``root.right.left.right ``=` `Node(``7``)` `    ``root.right.left.left ``=` `Node(``12``)` `    ``root.left.right.left ``=` `Node(``11``)` `    ``root.left.left.right ``=` `Node(``10``)`   `    ``# Function Call` `    ``v ``=` `diagonalSum(root)`   `    ``# Print the diagonal sums` `    ``for` `i ``in` `v:` `        ``print``(i, end ``=` `" "``)`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# Program to calculate the` `// sum of diagonal nodes.` `using` `System;` `using` `System.Collections.Generic;` `public` `class` `GFG` `{`   `// Node Structure` `public` ` ``class` `Node` `{` `    ``public` ` ``int` `data;` `    ``public` ` ``Node left, right;` `};`   `// to map the node with level - index` `static` `Dictionary<``int``, ``int``> grid = ``new` `Dictionary<``int``, ``int``>();`   `// Function to create new node` `static` `Node newNode(``int` `data)` `{` `    ``Node Node = ``new` `Node();` `    ``Node.data = data;` `    ``Node.left = Node.right = ``null``;` `    ``return` `Node;` `}`   `// recursvise function to calculate sum of elements` `// where level - index is same.` `static` `void` `addConsideringGrid(Node root, ``int` `level, ``int` `index)` `{`   `    ``// if there is no child then return` `    ``if` `(root == ``null``)` `        ``return``;`   `    ``// add the element in the group of node` `    ``// whose level - index is equal` `    ``if``(grid.ContainsKey(level - index))` `    ``grid[level - index] = grid[level - index] + (root.data);` `    ``else` `        ``grid.Add(level-index, root.data);`   `    ``// left child call` `    ``addConsideringGrid(root.left, level + 1, index - 1);`   `    ``// right child call` `    ``addConsideringGrid(root.right, level + 1, index + 1);` `}`   `static` `List<``int``> diagonalSum(Node root)` `{` `    ``grid.Clear();`   `    ``// Function call` `    ``addConsideringGrid(root, 0, 0);` `    ``List<``int``> ans = ``new` `List<``int``>();`   `    ``// for different values of level - index` `    ``// add te sum of those node to answer` `    ``foreach` `(KeyValuePair<``int``,``int``> x ``in` `grid) ` `    ``{` `        ``ans.Add(x.Value);` `    ``}` `    ``return` `ans;` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{`   `    ``// build binary tree` `    ``Node root = newNode(1);` `    ``root.left = newNode(2);` `    ``root.right = newNode(3);` `    ``root.left.left = newNode(9);` `    ``root.left.right = newNode(6);` `    ``root.right.left = newNode(4);` `    ``root.right.right = newNode(5);` `    ``root.right.left.right = newNode(7);` `    ``root.right.left.left = newNode(12);` `    ``root.left.right.left = newNode(11);` `    ``root.left.left.right = newNode(10);`   `    ``// Function Call` `    ``List<``int``> v = diagonalSum(root);`   `    ``// print the diagonal sums` `    ``for` `(``int` `i = 0; i < v.Count; i++)` `        ``Console.Write(v[i] + ``" "``);` `  ``}` `}`   `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

`9 19 42 `

Time Complexity-  O(n)

As every node is visited just once.

Auxiliary Space: O(h+d)

Here h is the height of the tree and d is the number of diagonals. The extra space is required for recursion call stack and to store the diagonal sum in the map. In the worst case(left skewed tree) this can go upto O(n).

### Method – 3

No Need to used Map for extra space.

space – o(n), queue used for left node left element for later processing

Time Complexity – o(n)

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Node Structure` `struct` `Node` `{` `    ``int` `data;` `    ``Node *left,*right;` `};`   `// to map the node with level - index`   `// Function to create new node` `Node* newNode(``int` `data)` `{` `    ``Node* node = ``new` `Node();` `    ``node->data = data;` `    ``node->left = node->right = NULL;` `    ``return` `node;` `}`     `vector<``int``> diagonalSum(Node* root){`   `    ``// list for storing diagonal sum` `    ``vector<``int``>list;` `    `  `    ``// list for processing diagonal left while traversing right` `    ``/*` `        ``1` `        ``2 3` `    ``4` `    ``1->3 while moving diagonally right` `    ``queue 2,4 // for processing later` `    ``*/` `    ``queueQueue;` `    ``int` `sum = 0; ``// sum of digoanl element` `    ``int` `count = 0; ``// number of element in next diagonal` `    ``int` `last = 0; ``// Number of element left to traverse current diagonal` `    ``while``(root != NULL)` `    ``{` `        ``if``(root->left != NULL)` `        ``{ ``// queue left` `            ``Queue.push(root->left);` `            ``count++; ``// count of next diagonal elements` `        ``}` `        ``sum += root->data;` `        ``root = root->right; ``//move diagonally right` `        ``if``(root == NULL){ ``// all element of diagonal is traversed` `            ``if``(!Queue.empty()){ ``// check queue for processing any left` `                ``root = Queue.front();` `                ``Queue.pop();` `            ``}` `            ``if``(last == 0){ ``// new diagonal sum , traversal of all element in current diagonal done or not` `                ``list.push_back(sum);` `                ``sum = 0;` `                ``last = count; ``// keep element in one diagonal` `                ``count = 0;` `            ``}` `            ``last--;` `        ``}` `    ``}` `    ``return` `list;` `        `  `}`   `// Driver code` `int` `main()` `{`   `    ``// build binary tree` `    ``Node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->left->left = newNode(9);` `    ``root->left->right = newNode(6);` `    ``root->right->left = newNode(4);` `    ``root->right->right = newNode(5);` `    ``root->right->left->right = newNode(7);` `    ``root->right->left->left = newNode(12);` `    ``root->left->right->left = newNode(11);` `    ``root->left->left->right = newNode(10);`   `    ``// Function Call` `    ``vector<``int``>v = diagonalSum(root);`   `    ``// print the diagonal sums` `    ``for` `(``int` `i = 0; i < v.size(); i++)` `        ``cout << v[i] << ``" "``;` `}`   `// This code is contributed by shinjanpatra`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG {`   `    ``// Node Structure` `    ``static` `class` `Node {` `        ``int` `data;` `        ``Node left, right;` `    ``};`   `    ``// to map the node with level - index`   `    ``// Function to create new node` `    ``static` `Node newNode(``int` `data)` `    ``{` `        ``Node Node = ``new` `Node();` `        ``Node.data = data;` `        ``Node.left = Node.right = ``null``;` `        ``return` `Node;` `    ``}`   `    ``public` `static` `ArrayList diagonalSum(Node root)` `    ``{`   `        ``// list for storing diagonal sum` `        ``ArrayList list = ``new` `ArrayList();`   `        ``// list for processing diagonal left while` `        ``// traversing right` `        ``/*` `               ``1` `             ``2    3` `                 ``4` `           ``1->3 while moving diagonally right` `           ``queue 2,4 // for processing later` `        ``*/` `        ``Queue queue = ``new` `LinkedList();` `        ``int` `sum = ``0``; ``// sum of digoanl element` `        ``int` `count = ``0``; ``// number of element in next diagonal` `        ``int` `last = ``0``; ``// Number of element left to traverse` `                      ``// current diagonal` `        ``while` `(root != ``null``) {` `            ``if` `(root.left != ``null``) { ``// queue left` `                ``queue.add(root.left);` `                ``count++; ``// count of next diagonal elements` `            ``}` `            ``sum += root.data;` `            ``root = root.right; ``// move diagonally right` `            ``if` `(root == ``null``) { ``// all element of diagonal` `                                ``// is traversed` `                ``if` `(!queue.isEmpty()) { ``// check queue for` `                                        ``// processing any` `                                        ``// left` `                    ``root = queue.poll();` `                ``}` `                ``if` `(last` `                    ``== ``0``) { ``// new diagonal sum , traversal` `                            ``// of all element in current` `                            ``// diagonal done or not` `                    ``list.add(sum);` `                    ``sum = ``0``;` `                    ``last = count; ``// keep element in one` `                                  ``// diagonal` `                    ``count = ``0``;` `                ``}` `                ``last--;` `            ``}` `        ``}` `        ``return` `list;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``// build binary tree` `        ``Node root = newNode(``1``);` `        ``root.left = newNode(``2``);` `        ``root.right = newNode(``3``);` `        ``root.left.left = newNode(``9``);` `        ``root.left.right = newNode(``6``);` `        ``root.right.left = newNode(``4``);` `        ``root.right.right = newNode(``5``);` `        ``root.right.left.right = newNode(``7``);` `        ``root.right.left.left = newNode(``12``);` `        ``root.left.right.left = newNode(``11``);` `        ``root.left.left.right = newNode(``10``);`   `        ``// Function Call` `        ``ArrayList v = diagonalSum(root);`   `        ``// print the diagonal sums` `        ``for` `(``int` `i = ``0``; i < v.size(); i++)` `            ``System.out.print(v.get(i) + ``" "``);` `    ``}` `}`

## Python3

 `# Python3 program for the above approach` `from` `collections ``import` `deque`   `# A binary tree node structure`     `class` `Node:` `    ``def` `__init__(``self``, key):`   `        ``self``.data ``=` `key` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`     `def` `diagonalSum(root):` `    ``# list for storing diagonal sum` `    ``list` `=` `[]`   `    ``# list for processing diagonal left while` `    ``# traversing right` `    ``#` `    ``#      1` `    ``#    2    3` `    ``#        4` `    ``#  1->3 while moving diagonally right` `    ``#  queue 2,4 // for processing later` `    ``#` `    ``queue ``=` `[]` `    ``sum` `=` `0`  `# sum of digoanl element` `    ``count ``=` `0`  `# number of element in next diagonal` `    ``last ``=` `0`  `# Number of element left to traverse` `    ``# current diagonal` `    ``while` `(root !``=` `None``):` `        ``if` `(root.left !``=` `None``):  ``# queue left` `            ``queue.append(root.left)` `            ``count ``+``=` `1`  `# count of next diagonal elements`   `        ``sum` `+``=` `root.data` `        ``root ``=` `root.right  ``# move diagonally right` `        ``if` `(root ``=``=` `None``):  ``# all element of diagonal` `                            ``# is traversed` `            ``if` `(``len``(queue) !``=` `0``):  ``# check queue for processing` `                            ``# any left` `                ``root ``=` `queue.pop(``0``)` `            ``if` `(last ``=``=` `0``):  ``# new diagonal sum , traversal` `                           ``# of all element in current` `                           ``# diagonal done or not` `                ``list``.append(``sum``)` `                ``sum` `=` `0` `                ``last ``=` `count  ``# keep element in one` `                ``# diagonal` `                ``count ``=` `0`   `            ``last ``-``=` `1`   `    ``return` `list`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``# Build binary tree` `    ``root ``=` `Node(``1``)` `    ``root.left ``=` `Node(``2``)` `    ``root.right ``=` `Node(``3``)` `    ``root.left.left ``=` `Node(``9``)` `    ``root.left.right ``=` `Node(``6``)` `    ``root.right.left ``=` `Node(``4``)` `    ``root.right.right ``=` `Node(``5``)` `    ``root.right.left.right ``=` `Node(``7``)` `    ``root.right.left.left ``=` `Node(``12``)` `    ``root.left.right.left ``=` `Node(``11``)` `    ``root.left.left.right ``=` `Node(``10``)`   `    ``# Function Call` `    ``v ``=` `diagonalSum(root)`   `    ``# Print the diagonal sums` `    ``for` `i ``in` `v:` `        ``print``(i, end``=``" "``)`   `# This code is contributed by Abhijeet Kumar(abhijeet19403)`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `public` `class` `GFG {`   `    ``// Node Structure` `    ``public` `class` `Node {` `        ``public` `int` `data;` `        ``public` `Node left, right;` `    ``};`   `    ``// Function to create new node` `    ``static` `Node newNode(``int` `data)` `    ``{` `        ``Node Node = ``new` `Node();` `        ``Node.data = data;` `        ``Node.left = Node.right = ``null``;` `        ``return` `Node;` `    ``}`   `    ``static` `List<``int``> diagonalSum(Node root)` `    ``{` `        ``// list for storing diagonal sum` `        ``List<``int``> list = ``new` `List<``int``>();`   `        ``// list for processing diagonal left while` `        ``// traversing right` `        ``/*` `               ``1` `             ``2    3` `                 ``4` `           ``1->3 while moving diagonally right` `           ``queue 2,4 // for processing later` `        ``*/` `        ``Queue queue = ``new` `Queue();` `        ``int` `sum = 0; ``// sum of digoanl element` `        ``int` `count = 0; ``// number of element in next diagonal` `        ``int` `last = 0; ``// Number of element left to traverse` `                      ``// current diagonal` `        ``while` `(root != ``null``) {` `            ``if` `(root.left != ``null``) { ``// queue left` `                ``queue.Enqueue(root.left);` `                ``count++; ``// count of next diagonal elements` `            ``}` `            ``sum += root.data;` `            ``root = root.right; ``// move diagonally right` `            ``if` `(root == ``null``) { ``// all element of diagonal` `                                ``// is traversed` `                ``if` `(queue.Count` `                    ``!= 0) { ``// check queue for processing` `                            ``// any left` `                    ``root = queue.Dequeue();` `                ``}` `                ``if` `(last` `                    ``== 0) { ``// new diagonal sum , traversal` `                            ``// of all element in current` `                            ``// diagonal done or not` `                    ``list.Add(sum);` `                    ``sum = 0;` `                    ``last = count; ``// keep element in one` `                                  ``// diagonal` `                    ``count = 0;` `                ``}` `                ``last--;` `            ``}` `        ``}` `        ``return` `list;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{`   `        ``// build binary tree` `        ``Node root = newNode(1);` `        ``root.left = newNode(2);` `        ``root.right = newNode(3);` `        ``root.left.left = newNode(9);` `        ``root.left.right = newNode(6);` `        ``root.right.left = newNode(4);` `        ``root.right.right = newNode(5);` `        ``root.right.left.right = newNode(7);` `        ``root.right.left.left = newNode(12);` `        ``root.left.right.left = newNode(11);` `        ``root.left.left.right = newNode(10);`   `        ``// Function Call` `        ``List<``int``> v = diagonalSum(root);`   `        ``// print the diagonal sums` `        ``for` `(``int` `i = 0; i < v.Count; i++)` `            ``Console.Write(v[i] + ``" "``);` `    ``}` `}`   `// This code is contributed by Abhijeet Kumar(abhijeet19403)`

## Javascript

 ``

Output

`9 19 42 `

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