# Tilt of Binary Tree

Given a binary tree, return the tilt of the whole tree. The tilt of a tree node is defined as the absolute difference between the sum of all left subtree node values and the sum of all right subtree node values. Null nodes are assigned tilt to be zero. Therefore, tilt of the whole tree is defined as the sum of all nodes’ tilt.

Examples:

```Input :
1
/ \
2   3
Output : 1
Explanation:
Tilt of node 2 : 0
Tilt of node 3 : 0
Tilt of node 1 : |2-3| = 1
Tilt of binary tree : 0 + 0 + 1 = 1

Input :
4
/ \
2   9
/ \   \
3   5   7
Output : 15
Explanation:
Tilt of node 3 : 0
Tilt of node 5 : 0
Tilt of node 7 : 0
Tilt of node 2 : |3-5| = 2
Tilt of node 9 : |0-7| = 7
Tilt of node 4 : |(3+5+2)-(9+7)| = 6
Tilt of binary tree : 0 + 0 + 0 + 2 + 7 + 6 = 15
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The idea is to recursively traverse tree. While traversing, we keep track of two things, sum of subtree rooted under current node, tilt of current node. Sum is needed to compute tilt of parent.

## C++

 `// CPP Program to find Tilt of Binary Tree ` `#include ` `using` `namespace` `std; ` ` `  `/* A binary tree node has data, pointer to ` `left child and a pointer to right child */` `struct` `Node { ` `    ``int` `val; ` `    ``struct` `Node *left, *right; ` `}; ` ` `  `/* Recursive function to calculate Tilt of ` `  ``whole tree */` `int` `traverse(Node* root, ``int``* tilt) ` `{ ` `    ``if` `(!root) ` `        ``return` `0; ` ` `  `    ``// Compute tilts of left and right subtrees ` `    ``// and find sums of left and right subtrees ` `    ``int` `left = traverse(root->left, tilt); ` `    ``int` `right = traverse(root->right, tilt);  ` ` `  `    ``// Add current tilt to overall ` `    ``*tilt += ``abs``(left - right); ` ` `  `    ``// Returns sum of nodes under current tree ` `    ``return` `left + right + root->val; ` `} ` ` `  `/* Driver function to print Tilt of whole tree */` `int` `Tilt(Node* root) ` `{ ` `    ``int` `tilt = 0; ` `    ``traverse(root, &tilt); ` `    ``return` `tilt; ` `} ` ` `  `/* Helper function that allocates a ` `new node with the given data and ` `NULL left and right pointers. */` `Node* newNode(``int` `data) ` `{ ` `    ``Node* temp = ``new` `Node; ` `    ``temp->val = data; ` `    ``temp->left = temp->right = NULL; ` `    ``return` `temp; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``/* Let us construct a Binary Tree ` `        ``4 ` `       ``/ \ ` `      ``2   9 ` `     ``/ \   \ ` `    ``3   5   7 */` ` `  `    ``Node* root = NULL; ` `    ``root = newNode(4); ` `    ``root->left = newNode(2); ` `    ``root->right = newNode(9); ` `    ``root->left->left = newNode(3); ` `    ``root->left->right = newNode(8); ` `    ``root->right->right = newNode(7); ` `    ``cout << ``"The Tilt of whole tree is "` `<< Tilt(root); ` `    ``return` `0; ` `} `

## Java

 `// Java Program to find Tilt of Binary Tree  ` `import` `java.util.*; ` `class` `GfG { ` ` `  `/* A binary tree node has data, pointer to  ` `left child and a pointer to right child */` `static` `class` `Node {  ` `    ``int` `val;  ` `    ``Node left, right;  ` `} ` ` `  `/* Recursive function to calculate Tilt of  ` `whole tree */` `static` `class` `T{ ` `    ``int` `tilt = ``0``; ` `} ` `static` `int` `traverse(Node root, T t )  ` `{  ` `    ``if` `(root == ``null``)  ` `        ``return` `0``;  ` ` `  `    ``// Compute tilts of left and right subtrees  ` `    ``// and find sums of left and right subtrees  ` `    ``int` `left = traverse(root.left, t);  ` `    ``int` `right = traverse(root.right, t);  ` ` `  `    ``// Add current tilt to overall  ` `    ``t.tilt += Math.abs(left - right);  ` ` `  `    ``// Returns sum of nodes under current tree  ` `    ``return` `left + right + root.val;  ` `}  ` ` `  `/* Driver function to print Tilt of whole tree */` `static` `int` `Tilt(Node root)  ` `{  ` `    ``T t = ``new` `T();  ` `    ``traverse(root, t);  ` `    ``return` `t.tilt;  ` `}  ` ` `  `/* Helper function that allocates a  ` `new node with the given data and  ` `NULL left and right pointers. */` `static` `Node newNode(``int` `data)  ` `{  ` `    ``Node temp = ``new` `Node();  ` `    ``temp.val = data;  ` `    ``temp.left = ``null``; ` `    ``temp.right = ``null``;  ` `    ``return` `temp;  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``/* Let us construct a Binary Tree  ` `        ``4  ` `    ``/ \  ` `    ``2 9  ` `    ``/ \ \  ` `    ``3 5 7 */` ` `  `    ``Node root = ``null``;  ` `    ``root = newNode(``4``);  ` `    ``root.left = newNode(``2``);  ` `    ``root.right = newNode(``9``);  ` `    ``root.left.left = newNode(``3``);  ` `    ``root.left.right = newNode(``8``);  ` `    ``root.right.right = newNode(``7``);  ` `    ``System.out.println(``"The Tilt of whole tree is "` `+ Tilt(root));  ` `} ` `}  `

## Python3

 `# Python3 Program to find Tilt of  ` `# Binary Tree  ` ` `  `# class that allocates a new node  ` `# with the given data and  ` `# None left and right pointers.  ` `class` `newNode: ` `    ``def` `__init__(``self``, data): ` `        ``self``.val ``=` `data  ` `        ``self``.left ``=` `self``.right ``=` `None` ` `  `# Recursive function to calculate ` `# Tilt of whole tree  ` `def` `traverse(root, tilt): ` `    ``if` `(``not` `root):  ` `        ``return` `0` ` `  `    ``# Compute tilts of left and right subtrees  ` `    ``# and find sums of left and right subtrees  ` `    ``left ``=` `traverse(root.left, tilt)  ` `    ``right ``=` `traverse(root.right, tilt)  ` ` `  `    ``# Add current tilt to overall  ` `    ``tilt[``0``] ``+``=` `abs``(left ``-` `right)  ` ` `  `    ``# Returns sum of nodes under  ` `    ``# current tree  ` `    ``return` `left ``+` `right ``+` `root.val ` ` `  `# Driver function to print Tilt ` `# of whole tree  ` `def` `Tilt(root): ` `    ``tilt ``=` `[``0``] ` `    ``traverse(root, tilt)  ` `    ``return` `tilt[``0``] ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``# Let us construct a Binary Tree  ` `    ``#     4  ` `    ``# / \  ` `    ``# 2 9  ` `    ``# / \ \  ` `    ``# 3 5 7  ` `    ``root ``=` `None` `    ``root ``=` `newNode(``4``)  ` `    ``root.left ``=` `newNode(``2``)  ` `    ``root.right ``=` `newNode(``9``)  ` `    ``root.left.left ``=` `newNode(``3``)  ` `    ``root.left.right ``=` `newNode(``8``)  ` `    ``root.right.right ``=` `newNode(``7``)  ` `    ``print``(``"The Tilt of whole tree is"``,  ` `                           ``Tilt(root)) ` ` `  `# This code is contributed by PranchalK `

## C#

 `// C# Program to find Tilt of Binary Tree  ` `using` `System; ` ` `  `class` `GfG  ` `{ ` ` `  `/* A binary tree node has data, pointer to  ` `left child and a pointer to right child */` `public` `class` `Node  ` `{  ` `    ``public` `int` `val;  ` `    ``public` `Node left, right;  ` `} ` ` `  `/* Recursive function to calculate Tilt of  ` `whole tree */` `public` `class` `T ` `{ ` `    ``public` `int` `tilt = 0; ` `} ` `static` `int` `traverse(Node root, T t )  ` `{  ` `    ``if` `(root == ``null``)  ` `        ``return` `0;  ` ` `  `    ``// Compute tilts of left and right subtrees  ` `    ``// and find sums of left and right subtrees  ` `    ``int` `left = traverse(root.left, t);  ` `    ``int` `right = traverse(root.right, t);  ` ` `  `    ``// Add current tilt to overall  ` `    ``t.tilt += Math.Abs(left - right);  ` ` `  `    ``// Returns sum of nodes under current tree  ` `    ``return` `left + right + root.val;  ` `}  ` ` `  `/* Driver function to print Tilt of whole tree */` `static` `int` `Tilt(Node root)  ` `{  ` `    ``T t = ``new` `T();  ` `    ``traverse(root, t);  ` `    ``return` `t.tilt;  ` `}  ` ` `  `/* Helper function that allocates a  ` `new node with the given data and  ` `NULL left and right pointers. */` `static` `Node newNode(``int` `data)  ` `{  ` `    ``Node temp = ``new` `Node();  ` `    ``temp.val = data;  ` `    ``temp.left = ``null``; ` `    ``temp.right = ``null``;  ` `    ``return` `temp;  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main(String[] args)  ` `{  ` `    ``/* Let us construct a Binary Tree  ` `        ``4  ` `    ``/ \  ` `    ``2 9  ` `    ``/ \ \  ` `    ``3 5 7 */` ` `  `    ``Node root = ``null``;  ` `    ``root = newNode(4);  ` `    ``root.left = newNode(2);  ` `    ``root.right = newNode(9);  ` `    ``root.left.left = newNode(3);  ` `    ``root.left.right = newNode(8);  ` `    ``root.right.right = newNode(7);  ` `    ``Console.WriteLine(``"The Tilt of whole tree is "` `+ Tilt(root));  ` `} ` `} ` ` `  `// This code contributed by Rajput-Ji `

Output:

```The Tilt of whole tree is 15
```

Complexity Analysis:

• Time complexity : O(n), where n is the number of nodes in binary tree.
• Auxiliary Space : O(n) as in worst case, depth of binary tree will be n.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.