Given a Binary Tree having positive and negative nodes, the task is to find the maximum absolute difference of level sum in it.

**Examples:**

Input:4 / \ 2 -5 / \ / \ -1 3 -2 6Output:9Explanation:Sum of all nodes of 0 level is 4 Sum of all nodes of 1 level is -3 Sum of all nodes of 2 level is 6 Hence maximum absolute difference of level sum = 9 (6 - (-3))Input:1 / \ 2 3 / \ \ 4 5 8 / \ 6 7Output:16

**Approach: **To find the maximum absolute difference of level sum, we only need to find **Maximum level sum** and **Minimum level sum** because absolute difference of maximum and minimum level sum always gives us Maximum absolute difference, i.e.

Maximum absolute difference = abs(Maximum level sum – Minimum level sum)

Below are the steps for algorithm of above observation:

- The idea is to do level order traversal of the tree.
- While doing traversal, process nodes of different levels separately.
- For every level being processed, compute sum of nodes in the level and keep track of
**maximum**and**minimum**level sum. - Then return the
**absolute difference**of maximum and minimum level sum.

Below is the implementation of the above approach:

## Java

`// Java program to find the maximum ` `// absolute difference of level ` `// sum in Binary Tree ` ` ` `import` `java.util.*; ` ` ` `// Class containing left and ` `// right child of current ` `// node and key value ` `class` `Node { ` ` ` ` ` `int` `data; ` ` ` `Node left, right; ` ` ` ` ` `public` `Node(` `int` `item) ` ` ` `{ ` ` ` `data = item; ` ` ` `left = right = ` `null` `; ` ` ` `} ` `} ` ` ` `class` `BinaryTree { ` ` ` ` ` `// Root of the Binary Tree ` ` ` `Node root; ` ` ` ` ` `public` `BinaryTree() ` ` ` `{ ` ` ` `root = ` `null` `; ` ` ` `} ` ` ` ` ` `// Function to find ` ` ` `// the maximum absolute ` ` ` `// difference of level ` ` ` `// sum in binary tree ` ` ` `// using level order traversal ` ` ` `public` `int` `maxAbsDiffLevelSum() ` ` ` `{ ` ` ` ` ` `// Initialize value of maximum ` ` ` `// and minimum level sum ` ` ` `int` `maxsum = Integer.MIN_VALUE; ` ` ` `int` `minsum = Integer.MAX_VALUE; ` ` ` ` ` `Queue<Node> qu = ` `new` `LinkedList<>(); ` ` ` `qu.offer(root); ` ` ` ` ` `// Do Level order traversal ` ` ` `// keeping track of number ` ` ` `// of nodes at every level. ` ` ` `while` `(!qu.isEmpty()) { ` ` ` ` ` `// Get the size of queue when ` ` ` `// the level order traversal ` ` ` `// for one level finishes ` ` ` `int` `sz = qu.size(); ` ` ` ` ` `// Iterate for all the nodes in ` ` ` `// the queue currently ` ` ` `int` `sum = ` `0` `; ` ` ` ` ` `for` `(` `int` `i = ` `0` `; i < sz; i++) { ` ` ` ` ` `// Dequeue an node from queue ` ` ` `Node t = qu.poll(); ` ` ` ` ` `// Add this node's value to ` ` ` `// the current sum. ` ` ` `sum += t.data; ` ` ` ` ` `// Enqueue left and ` ` ` `// right children of ` ` ` `// dequeued node ` ` ` `if` `(t.left != ` `null` `) ` ` ` `qu.offer(t.left); ` ` ` ` ` `if` `(t.right != ` `null` `) ` ` ` `qu.offer(t.right); ` ` ` `} ` ` ` ` ` `// Update the maximum ` ` ` `// level sum value ` ` ` `maxsum = Math.max(maxsum, sum); ` ` ` ` ` `// Update the minimum ` ` ` `// level sum value ` ` ` `minsum = Math.min(minsum, sum); ` ` ` `} ` ` ` `// return the maximum absolute ` ` ` `// difference of level sum ` ` ` `return` `Math.abs(maxsum - minsum); ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `BinaryTree tree = ` `new` `BinaryTree(); ` ` ` `tree.root = ` `new` `Node(` `4` `); ` ` ` `tree.root.left = ` `new` `Node(` `2` `); ` ` ` `tree.root.right = ` `new` `Node(-` `5` `); ` ` ` `tree.root.left.left = ` `new` `Node(-` `1` `); ` ` ` `tree.root.left.right = ` `new` `Node(` `3` `); ` ` ` `tree.root.right.left = ` `new` `Node(-` `2` `); ` ` ` `tree.root.right.right = ` `new` `Node(` `6` `); ` ` ` ` ` `/* Constructed Binary tree is: ` ` ` `4 ` ` ` `/ \ ` ` ` `2 -5 ` ` ` `/ \ / \ ` ` ` `-1 3 -2 6 */` ` ` ` ` `System.out.println( ` ` ` `tree.maxAbsDiffLevelSum()); ` ` ` `} ` `} ` |

*chevron_right*

*filter_none*

**Output:**

9

**Time Complexity:** O(N)

**Auxiliary Space: **O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Maximum absolute difference between any two level sum in a N-ary Tree
- Difference between sums of odd level and even level nodes of a Binary Tree
- Check if max sum level of Binary tree divides tree into two equal sum halves
- Difference between sums of odd level and even level nodes in an N-ary Tree
- Minimum difference between any two weighted nodes in Sum Tree of the given Tree
- Count nodes from all lower levels smaller than minimum valued node of current level for every level in a Binary Tree
- Queries to find the maximum Xor value between X and the nodes of a given level of a perfect binary tree
- Find maximum level sum in Binary Tree
- Find Maximum Level Sum in Binary Tree using Recursion
- Print nodes between two given level numbers of a binary tree
- Maximum sub-tree sum in a Binary Tree such that the sub-tree is also a BST
- Difference between sums of odd position and even position nodes for each level of a Binary Tree
- Difference between Binary Tree and Binary Search Tree
- XOR of path between any two nodes in a Binary Tree
- Print path between any two nodes in a Binary Tree
- Print path between any two nodes in a Binary Tree | Set 2
- Given level order traversal of a Binary Tree, check if the Tree is a Min-Heap
- Find the maximum path sum between two leaves of a binary tree
- Find maximum level product in Binary Tree
- Find the maximum node at a given level in a binary tree

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.