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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP Program to find Tilt of Binary Tree
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 
        
    / \ 
    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)); 
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 
        
    / \ 
    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

chevron_right



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.