Diagonal Sum of a Binary Tree
Last Updated :
23 Jul, 2025
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.
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.
- Add root with vertical distance as 0 to the queue.
- Process the sum of all right child and right of the right child and so on.
- 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.
- 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 <bits/stdc++.h>
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 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<TreeNode> queue = new LinkedList<TreeNode>();
// Map to store sum of node's data lying diagonally
Map<Integer, Integer> 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<Entry<Integer, Integer>> set = map.entrySet();
// Make an iterator
Iterator<Entry<Integer, Integer>> 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<Integer, Integer> 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();
}
}
# 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# 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<TreeNode> queue = new Queue<TreeNode>();
// 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<int, int> 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
<script>
// JavaScript Program to find diagonal
// sum in a Binary Tree
// Tree node
class TreeNode {
// Tree node constructor
constructor(data) {
this.data = data; // node data
this.vd = 2147483647; // vertical distance diagonally
this.left = null; // left and right child's reference
this.right = null;
}
}
// Tree class
class Tree {
// Tree constructor
constructor(root) {
this.root = root; //T ree root
}
// Diagonal sum method
diagonalSum() {
// Queue which stores tree nodes
var queue = [];
// Map to store sum of node's data lying diagonally
var map = {};
// Assign the root's vertical distance as 0.
this.root.vd = 0;
// Add root node to the queue
queue.push(this.root);
// Loop while the queue is not empty
while (queue.length != 0) {
// Remove the front tree node from queue.
var curr = queue.shift();
// Get the vertical distance of the dequeued node.
var vd = curr.vd;
// Sum over this node's right-child,
// right-of-right-child
// and so on
while (curr != null) {
var prevSum;
if (!map.hasOwnProperty(vd))
prevSum = 0;
else prevSum = map[vd];
if (map.hasOwnProperty(vd))
map[vd] = prevSum + curr.data;
else
map[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.push(curr.left);
}
// Move to the current node's right child.
curr = curr.right;
}
}
// Traverse the map elements using the iterator.
document.write("Diagonal sum in a binary tree is - ");
for (const [key, value] of Object.entries(map)) {
// Map.Entry<int, int> me = iterator.next();
document.write(value + " ");
}
}
}
// Driver class
var 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);
var tree = new Tree(root);
tree.diagonalSum();
</script>
OutputDiagonal 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)
| Nodes | Level Index | Width Index |
1
| 0 | 0 |
2
| 1 | -1 |
3
| 1 | 1 |
4
| 2 | 0 |
5
| 2 | 2 |
6
| 2 | 0 |
7
| 3 | 1 |
9
| 2 | -2 |
10
| 3 | -1 |
11
| 3 | -1 |
12
| 3 | -1 |
To help you visualize let's draw a matrix, the first row and first column, are respective width and level indices-
| | -2 | -1
| 0 | 1 | 2 |
| 0 | | | 1 | | |
| 1 | | 2
| | 3 | |
| 2 | 9 | | 6+4 | | 5 |
| 3 | | 10+11+12 | | 7 | |
Below is the implementation of the above idea:
C++
// C++ Program to calculate the
// sum of diagonal nodes.
#include <bits/stdc++.h>
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 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<Integer,Integer> 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<Integer> diagonalSum(Node root)
{
grid.clear();
// Function call
addConsideringGrid(root, 0, 0);
Vector<Integer> ans = new Vector<>();
// for different values of level - index
// add te sum of those node to answer
for (Map.Entry<Integer,Integer> 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<Integer> 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 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# 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
<script>
// Javascript Program to calculate the
// sum of diagonal nodes.
// Node Structure
class Node
{
// Function to create new node
constructor(data)
{
this.data=data;
this.left=null;
this.right=null;
}
}
// to map the node with level - index
let grid = new Map();
// recursvise function to calculate
// sum of elements
// where level - index is same.
function addConsideringGrid(root,level,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.has(level-index))
{
grid.set(level - index,grid.get(level-index) +
(root.data));
}
else
{
grid.set(level-index, root.data);
}
// left child call
addConsideringGrid(root.left, level + 1, index - 1);
// right child call
addConsideringGrid(root.right, level + 1, index + 1);
}
function diagonalSum(root)
{
// Function call
addConsideringGrid(root, 0, 0);
let ans = [];
// for different values of level - index
// add te sum of those node to answer
for (let [key, value] of grid)
{
ans.push(value);
}
return ans;
}
// Driver code
// build binary tree
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(9);
root.left.right = new Node(6);
root.right.left = new Node(4);
root.right.right = new Node(5);
root.right.left.right = new Node(7);
root.right.left.left = new Node(12);
root.left.right.left = new Node(11);
root.left.left.right = new Node(10);
// Function Call
let v = diagonalSum(root);
// print the diagonal sums
for (let i = 0; i < v.length; i++)
document.write(v[i] + " ");
// This code is contributed by unknown2108
</script>
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<bits/stdc++.h>
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
*/
queue<Node*>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.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 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<Integer> diagonalSum(Node root)
{
// list for storing diagonal sum
ArrayList<Integer> list = new ArrayList<Integer>();
// 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<Node> queue = new LinkedList<Node>();
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<Integer> v = diagonalSum(root);
// print the diagonal sums
for (int i = 0; i < v.size(); i++)
System.out.print(v.get(i) + " ");
}
}
# 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# 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<Node> queue = new Queue<Node>();
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)
<script>
// JavaScript program for the above approach
// Node Structure
class Node
{
constructor(data = 0,left = null,right = null){
this.data = data;
this.left = this.right = null;
}
}
// to map the node with level - index
// Function to create new node
function newNode(data)
{
let node = new Node();
node.data = data;
node.left = node.right = null;
return node;
}
function diagonalSum(root){
// list for storing diagonal sum
let 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
*/
let Queue = [];
let sum = 0; // sum of digoanl element
let count = 0; // number of element in next diagonal
let 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.length > 0){ // check queue for processing any left
root = Queue.shift();
}
if(last == 0){ // new diagonal sum , traversal of all element in current diagonal done or not
list.push(sum);
sum = 0;
last = count; // keep element in one diagonal
count = 0;
}
last--;
}
}
return list;
}
// Driver code
// build binary tree
let 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
let v = diagonalSum(root);
// print the diagonal sums
for (let i = 0; i < v.length; i++)
document.write(v[i] + " ");
// This code is contributed by shinjanpatra
</script>
Diagonal sum in binary tree | DSA Problem
Similar Reads
Basics & Prerequisites
Data Structures
Array Data StructureIn this article, we introduce array, implementation in different popular languages, its basic operations and commonly seen problems / interview questions. An array stores items (in case of C/C++ and Java Primitive Arrays) or their references (in case of Python, JS, Java Non-Primitive) at contiguous
3 min read
String in Data StructureA string is a sequence of characters. The following facts make string an interesting data structure.Small set of elements. Unlike normal array, strings typically have smaller set of items. For example, lowercase English alphabet has only 26 characters. ASCII has only 256 characters.Strings are immut
2 min read
Hashing in Data StructureHashing is a technique used in data structures that efficiently stores and retrieves data in a way that allows for quick access. Hashing involves mapping data to a specific index in a hash table (an array of items) using a hash function. It enables fast retrieval of information based on its key. The
2 min read
Linked List Data StructureA linked list is a fundamental data structure in computer science. It mainly allows efficient insertion and deletion operations compared to arrays. Like arrays, it is also used to implement other data structures like stack, queue and deque. Here’s the comparison of Linked List vs Arrays Linked List:
2 min read
Stack Data StructureA Stack is a linear data structure that follows a particular order in which the operations are performed. The order may be LIFO(Last In First Out) or FILO(First In Last Out). LIFO implies that the element that is inserted last, comes out first and FILO implies that the element that is inserted first
2 min read
Queue Data StructureA Queue Data Structure is a fundamental concept in computer science used for storing and managing data in a specific order. It follows the principle of "First in, First out" (FIFO), where the first element added to the queue is the first one to be removed. It is used as a buffer in computer systems
2 min read
Tree Data StructureTree Data Structure is a non-linear data structure in which a collection of elements known as nodes are connected to each other via edges such that there exists exactly one path between any two nodes. Types of TreeBinary Tree : Every node has at most two childrenTernary Tree : Every node has at most
4 min read
Graph Data StructureGraph Data Structure is a collection of nodes connected by edges. It's used to represent relationships between different entities. If you are looking for topic-wise list of problems on different topics like DFS, BFS, Topological Sort, Shortest Path, etc., please refer to Graph Algorithms. Basics of
3 min read
Trie Data StructureThe Trie data structure is a tree-like structure used for storing a dynamic set of strings. It allows for efficient retrieval and storage of keys, making it highly effective in handling large datasets. Trie supports operations such as insertion, search, deletion of keys, and prefix searches. In this
15+ min read
Algorithms
Searching AlgorithmsSearching algorithms are essential tools in computer science used to locate specific items within a collection of data. In this tutorial, we are mainly going to focus upon searching in an array. When we search an item in an array, there are two most common algorithms used based on the type of input
2 min read
Sorting AlgorithmsA Sorting Algorithm is used to rearrange a given array or list of elements in an order. For example, a given array [10, 20, 5, 2] becomes [2, 5, 10, 20] after sorting in increasing order and becomes [20, 10, 5, 2] after sorting in decreasing order. There exist different sorting algorithms for differ
3 min read
Introduction to RecursionThe process in which a function calls itself directly or indirectly is called recursion and the corresponding function is called a recursive function. A recursive algorithm takes one step toward solution and then recursively call itself to further move. The algorithm stops once we reach the solution
14 min read
Greedy AlgorithmsGreedy algorithms are a class of algorithms that make locally optimal choices at each step with the hope of finding a global optimum solution. At every step of the algorithm, we make a choice that looks the best at the moment. To make the choice, we sometimes sort the array so that we can always get
3 min read
Graph AlgorithmsGraph is a non-linear data structure like tree data structure. The limitation of tree is, it can only represent hierarchical data. For situations where nodes or vertices are randomly connected with each other other, we use Graph. Example situations where we use graph data structure are, a social net
3 min read
Dynamic Programming or DPDynamic Programming is an algorithmic technique with the following properties.It is mainly an optimization over plain recursion. Wherever we see a recursive solution that has repeated calls for the same inputs, we can optimize it using Dynamic Programming. The idea is to simply store the results of
3 min read
Bitwise AlgorithmsBitwise algorithms in Data Structures and Algorithms (DSA) involve manipulating individual bits of binary representations of numbers to perform operations efficiently. These algorithms utilize bitwise operators like AND, OR, XOR, NOT, Left Shift, and Right Shift.BasicsIntroduction to Bitwise Algorit
4 min read
Advanced
Segment TreeSegment Tree is a data structure that allows efficient querying and updating of intervals or segments of an array. It is particularly useful for problems involving range queries, such as finding the sum, minimum, maximum, or any other operation over a specific range of elements in an array. The tree
3 min read
Pattern SearchingPattern searching algorithms are essential tools in computer science and data processing. These algorithms are designed to efficiently find a particular pattern within a larger set of data. Patten SearchingImportant Pattern Searching Algorithms:Naive String Matching : A Simple Algorithm that works i
2 min read
GeometryGeometry is a branch of mathematics that studies the properties, measurements, and relationships of points, lines, angles, surfaces, and solids. From basic lines and angles to complex structures, it helps us understand the world around us.Geometry for Students and BeginnersThis section covers key br
2 min read
Interview Preparation
Practice Problem