In this guide, you will get 563. Binary Tree TiltLeetCode Solution with the best time and space complexity. The solution to Binary Tree Tilt problem is provided in various programming languages like C++, Java, and Python. This will be helpful for you if you are preparing for placements, hackathons, interviews, or practice purposes. The solutions provided here are very easy to follow and include detailed explanations.
Given the root of a binary tree, return the sum of every tree node’s tilt.
The tilt of a tree node is the absolute difference between the sum of all left subtree node values and all right subtree node values. If a node does not have a left child, then the sum of the left subtree node values is treated as 0. The rule is similar if the node does not have a right child.
Example 1:
Input: root = [1,2,3]
Output: 1
Explanation:
Tilt of node 2 : |0-0| = 0 (no children)
Tilt of node 3 : |0-0| = 0 (no children)
Tilt of node 1 : |2-3| = 1 (left subtree is just left child, so sum is 2; right subtree is just right child, so sum is 3)
Sum of every tilt : 0 + 0 + 1 = 1
Example 2:
Input: root = [4,2,9,3,5,null,7]
Output: 15
Explanation:
Tilt of node 3 : |0-0| = 0 (no children)
Tilt of node 5 : |0-0| = 0 (no children)
Tilt of node 7 : |0-0| = 0 (no children)
Tilt of node 2 : |3-5| = 2 (left subtree is just left child, so sum is 3; right subtree is just right child, so sum is 5)
Tilt of node 9 : |0-7| = 7 (no left child, so sum is 0; right subtree is just right child, so sum is 7)
Tilt of node 4 : |(3+5+2)-(9+7)| = |10-16| = 6 (left subtree values are 3, 5, and 2, which sums to 10; right subtree values are 9 and 7, which sums to 16)
Sum of every tilt : 0 + 0 + 0 + 2 + 7 + 6 = 15
The number of nodes in the tree is in the range [0, 104].
-1000 <= Node.val <= 1000
Complexity Analysis
Time Complexity: O(n)
Space Complexity: O(\log n)
563. Binary Tree TiltLeetCode Solution in C++
class Solution {
public:
int findTilt(TreeNode* root) {
int ans = 0;
sum(root, ans);
return ans;
}
private:
int sum(TreeNode* root, int& ans) {
if (root == nullptr)
return 0;
const int l = sum(root->left, ans);
const int r = sum(root->right, ans);
ans += abs(l - r);
return root->val + l + r;
}
}; /* code provided by PROGIEZ */
563. Binary Tree TiltLeetCode Solution in Java
class Solution {
public int findTilt(TreeNode root) {
sum(root);
return ans;
}
private int ans = 0;
private int sum(TreeNode root) {
if (root == null)
return 0;
final int l = sum(root.left);
final int r = sum(root.right);
ans += Math.abs(l - r);
return root.val + l + r;
}
} // code provided by PROGIEZ
563. Binary Tree TiltLeetCode Solution in Python
class Solution:
def findTilt(self, root: TreeNode | None) -> int:
ans = 0
def summ(root: TreeNode | None) -> None:
nonlocal ans
if not root:
return 0
l = summ(root.left)
r = summ(root.right)
ans += abs(l - r)
return root.val + l + r
summ(root)
return ans # code by PROGIEZ
