# Maximum difference between node and its ancestor in Binary Tree

Last Updated : 13 Oct, 2022

Given a Binary tree, The task is to find the maximum value by subtracting the value of node B from the value of node A, where A and B are two nodes of the binary tree and A is an ancestor of B.

Examples:

Input:

Output: 7
Explanation: We can have various ancestor-node difference, some of which are given below :
8 â€“ 3 = 5 , 3 â€“ 7 = -4, 8 â€“ 1 = 7, 10 â€“ 13 = -3
Among all those differences maximum value is 7 obtained by subtracting 1 from 8, which we need to return as result.

Input:
9
/  \
6    3
/  \
1    4
Output: 8

Approach:

Traverse whole binary tree to get max difference and we can obtain the result in one traversal only by following below steps :

• If current node is a leaf node then just return its value because it canâ€™t be ancestor of any node.
• Then at each internal node try to get minimum value from left subtree and right subtree and calculate the difference between node value and this minimum value and according to that update the result.

Follow the below steps to Implement the idea:

• Recursively traverse every node (say t) of the tree:
• If t = NULL return INT_MAX
• If the current node is the leaf node then just return the node’s value.
• Recursively calling for left and right subtree for minimum value
• Update res if node value – minimum value from subtree is bigger than res i.e res = max(*res, t->key – val).
• Return minimum value got so far i.e. return min(val, t->key);.

Below is the implementation of the above idea.

## C++

 `// C++ program to find maximum difference between node` `// and its ancestor` `#include ` `using` `namespace` `std;`   `/* A binary tree node has key, pointer to left` `   ``child and a pointer to right child */` `struct` `Node {` `    ``int` `key;` `    ``struct` `Node *left, *right;` `};`   `/* To create a newNode of tree and return pointer */` `struct` `Node* newNode(``int` `key)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->key = key;` `    ``temp->left = temp->right = NULL;` `    ``return` `(temp);` `}`   `/* Recursive function to calculate maximum ancestor-node` `   ``difference in  binary tree. It updates value at 'res'` `   ``to store the result.  The returned value of this function` `   ``is minimum value in subtree rooted with 't' */` `int` `maxDiffUtil(Node* t, ``int``* res)` `{` `    ``/* Returning Maximum int value if node is not` `       ``there (one child case)  */` `    ``if` `(t == NULL)` `        ``return` `INT_MAX;`   `    ``/* If leaf node then just return node's value  */` `    ``if` `(t->left == NULL && t->right == NULL)` `        ``return` `t->key;`   `    ``/* Recursively calling left and right subtree` `       ``for minimum value  */` `    ``int` `val = min(maxDiffUtil(t->left, res),` `                  ``maxDiffUtil(t->right, res));`   `    ``/* Updating res if (node value - minimum value` `       ``from subtree) is bigger than res  */` `    ``*res = max(*res, t->key - val);`   `    ``/* Returning minimum value got so far */` `    ``return` `min(val, t->key);` `}`   `/* This function mainly calls maxDiffUtil() */` `int` `maxDiff(Node* root)` `{` `    ``// Initialising result with minimum int value` `    ``int` `res = INT_MIN;`   `    ``maxDiffUtil(root, &res);`   `    ``return` `res;` `}`   `/* Helper function to print inorder traversal of` `  ``binary tree   */` `void` `inorder(Node* root)` `{` `    ``if` `(root) {` `        ``inorder(root->left);` `        ``cout << root->key << ``" "``;` `        ``inorder(root->right);` `    ``}` `}`   `// Driver program to test above functions` `int` `main()` `{` `    ``// Making above given diagram's binary tree` `    ``Node* root;` `    ``root = newNode(8);` `    ``root->left = newNode(3);`   `    ``root->left->left = newNode(1);` `    ``root->left->right = newNode(6);` `    ``root->left->right->left = newNode(4);` `    ``root->left->right->right = newNode(7);`   `    ``root->right = newNode(10);` `    ``root->right->right = newNode(14);` `    ``root->right->right->left = newNode(13);`   `    ``cout << maxDiff(root);` `}`

## Java

 `/* Java program to find maximum difference between node` `   ``and its ancestor */`   `// A binary tree node has key, pointer to left` `// and right child` `class` `Node {` `    ``int` `key;` `    ``Node left, right;`   `    ``public` `Node(``int` `key)` `    ``{` `        ``this``.key = key;` `        ``left = right = ``null``;` `    ``}` `}`   `/* Class Res created to implement pass by reference` `   ``of 'res' variable */` `class` `Res {` `    ``int` `r = Integer.MIN_VALUE;` `}`   `public` `class` `BinaryTree {` `    ``Node root;`   `    ``/* Recursive function to calculate maximum ancestor-node` `       ``difference in  binary tree. It updates value at 'res'` `       ``to store the result.  The returned value of this` `       ``function` `       ``is minimum value in subtree rooted with 't' */` `    ``int` `maxDiffUtil(Node t, Res res)` `    ``{` `        ``/* Returning Maximum int value if node is not` `           ``there (one child case)  */` `        ``if` `(t == ``null``)` `            ``return` `Integer.MAX_VALUE;`   `        ``/* If leaf node then just return node's value  */` `        ``if` `(t.left == ``null` `&& t.right == ``null``)` `            ``return` `t.key;`   `        ``/* Recursively calling left and right subtree` `           ``for minimum value  */` `        ``int` `val = Math.min(maxDiffUtil(t.left, res),` `                           ``maxDiffUtil(t.right, res));`   `        ``/* Updating res if (node value - minimum value` `           ``from subtree) is bigger than res  */` `        ``res.r = Math.max(res.r, t.key - val);`   `        ``/* Returning minimum value got so far */` `        ``return` `Math.min(val, t.key);` `    ``}`   `    ``/* This function mainly calls maxDiffUtil() */` `    ``int` `maxDiff(Node root)` `    ``{` `        ``// Initialising result with minimum int value` `        ``Res res = ``new` `Res();` `        ``maxDiffUtil(root, res);`   `        ``return` `res.r;` `    ``}`   `    ``/* Helper function to print inorder traversal of` `       ``binary tree   */` `    ``void` `inorder(Node root)` `    ``{` `        ``if` `(root != ``null``) {` `            ``inorder(root.left);` `            ``System.out.print(root.key + ``""``);` `            ``inorder(root.right);` `        ``}` `    ``}`   `    ``// Driver program to test the above functions` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``BinaryTree tree = ``new` `BinaryTree();`   `        ``// Making above given diagram's binary tree` `        ``tree.root = ``new` `Node(``8``);` `        ``tree.root.left = ``new` `Node(``3``);` `        ``tree.root.left.left = ``new` `Node(``1``);` `        ``tree.root.left.right = ``new` `Node(``6``);` `        ``tree.root.left.right.left = ``new` `Node(``4``);` `        ``tree.root.left.right.right = ``new` `Node(``7``);`   `        ``tree.root.right = ``new` `Node(``10``);` `        ``tree.root.right.right = ``new` `Node(``14``);` `        ``tree.root.right.right.left = ``new` `Node(``13``);`   `        ``System.out.println(tree.maxDiff(tree.root));` `    ``}` `}`   `// This code has been contributed by Mayank` `// Jaiswal(mayank_24)`

## Python3

 `# Python3 program to find maximum difference` `# between node and its ancestor`   `_MIN ``=` `-``2147483648` `_MAX ``=` `2147483648`   `# Helper function that allocates a new` `# node with the given data and None left` `# and right pointers.`     `class` `newNode:`   `    ``# Constructor to create a new node` `    ``def` `__init__(``self``, key):` `        ``self``.key ``=` `key` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`     `""" ` `Recursive function to calculate maximum ` `ancestor-node difference in binary tree. ` `It updates value at 'res' to store the ` `result. The returned value of this function` `is minimum value in subtree rooted with 't' """`     `def` `maxDiffUtil(t, res):` `    ``""" Returning Maximum value if node` `    ``is not there (one child case) """` `    ``if` `(t ``=``=` `None``):` `        ``return` `_MAX, res`   `    ``""" If leaf node then just return` `        ``node's value """` `    ``if` `(t.left ``=``=` `None` `and` `t.right ``=``=` `None``):` `        ``return` `t.key, res`   `    ``""" Recursively calling left and right ` `    ``subtree for minimum value """` `    ``a, res ``=` `maxDiffUtil(t.left, res)` `    ``b, res ``=` `maxDiffUtil(t.right, res)` `    ``val ``=` `min``(a, b)`   `    ``""" Updating res if (node value - minimum ` `    ``value from subtree) is bigger than res """` `    ``res ``=` `max``(res, t.key ``-` `val)`   `    ``""" Returning minimum value got so far """` `    ``return` `min``(val, t.key), res`     `""" This function mainly calls maxDiffUtil() """`     `def` `maxDiff(root):`   `    ``# Initialising result with minimum value` `    ``res ``=` `_MIN` `    ``x, res ``=` `maxDiffUtil(root, res)` `    ``return` `res`     `""" Helper function to print inorder` `traversal of binary tree """`     `def` `inorder(root):`   `    ``if` `(root):`   `        ``inorder(root.left)` `        ``prf(``"%d "``, root.key)` `        ``inorder(root.right)`     `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``""" ` `    ``Let us create Binary Tree shown` `    ``in above example """` `    ``root ``=` `newNode(``8``)` `    ``root.left ``=` `newNode(``3``)`   `    ``root.left.left ``=` `newNode(``1``)` `    ``root.left.right ``=` `newNode(``6``)` `    ``root.left.right.left ``=` `newNode(``4``)` `    ``root.left.right.right ``=` `newNode(``7``)`   `    ``root.right ``=` `newNode(``10``)` `    ``root.right.right ``=` `newNode(``14``)` `    ``root.right.right.left ``=` `newNode(``13``)` `    ``print``(maxDiff(root))`   `# This code is contributed by` `# Shubham Singh(SHUBHAMSINGH10)`

## C#

 `using` `System;`   `/* C# program to find maximum difference between node` `   ``and its ancestor */`   `// A binary tree node has key, pointer to left` `// and right child` `public` `class` `Node {` `    ``public` `int` `key;` `    ``public` `Node left, right;`   `    ``public` `Node(``int` `key)` `    ``{` `        ``this``.key = key;` `        ``left = right = ``null``;` `    ``}` `}`   `/* Class Res created to implement pass by reference` `   ``of 'res' variable */` `public` `class` `Res {` `    ``public` `int` `r = ``int``.MinValue;` `}`   `public` `class` `BinaryTree {` `    ``public` `Node root;`   `    ``/* Recursive function to calculate maximum ancestor-node` `       ``difference in  binary tree. It updates value at 'res'` `       ``to store the result.  The returned value of this` `       ``function` `       ``is minimum value in subtree rooted with 't' */` `    ``public` `virtual` `int` `maxDiffUtil(Node t, Res res)` `    ``{` `        ``/* Returning Maximum int value if node is not` `           ``there (one child case)  */` `        ``if` `(t == ``null``) {` `            ``return` `int``.MaxValue;` `        ``}`   `        ``/* If leaf node then just return node's value  */` `        ``if` `(t.left == ``null` `&& t.right == ``null``) {` `            ``return` `t.key;` `        ``}`   `        ``/* Recursively calling left and right subtree` `           ``for minimum value  */` `        ``int` `val = Math.Min(maxDiffUtil(t.left, res),` `                           ``maxDiffUtil(t.right, res));`   `        ``/* Updating res if (node value - minimum value` `           ``from subtree) is bigger than res  */` `        ``res.r = Math.Max(res.r, t.key - val);`   `        ``/* Returning minimum value got so far */` `        ``return` `Math.Min(val, t.key);` `    ``}`   `    ``/* This function mainly calls maxDiffUtil() */` `    ``public` `virtual` `int` `maxDiff(Node root)` `    ``{` `        ``// Initialising result with minimum int value` `        ``Res res = ``new` `Res();` `        ``maxDiffUtil(root, res);`   `        ``return` `res.r;` `    ``}`   `    ``/* Helper function to print inorder traversal of` `       ``binary tree   */` `    ``public` `virtual` `void` `inorder(Node root)` `    ``{` `        ``if` `(root != ``null``) {` `            ``inorder(root.left);` `            ``Console.Write(root.key + ``""``);` `            ``inorder(root.right);` `        ``}` `    ``}`   `    ``// Driver program to test the above functions` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``BinaryTree tree = ``new` `BinaryTree();`   `        ``// Making above given diagram's binary tree` `        ``tree.root = ``new` `Node(8);` `        ``tree.root.left = ``new` `Node(3);` `        ``tree.root.left.left = ``new` `Node(1);` `        ``tree.root.left.right = ``new` `Node(6);` `        ``tree.root.left.right.left = ``new` `Node(4);` `        ``tree.root.left.right.right = ``new` `Node(7);`   `        ``tree.root.right = ``new` `Node(10);` `        ``tree.root.right.right = ``new` `Node(14);` `        ``tree.root.right.right.left = ``new` `Node(13);`   `        ``Console.WriteLine(tree.maxDiff(tree.root));` `    ``}` `}`   `// This code is contributed by Shrikant13`

## Javascript

 ``

Output

`7`

Time Complexity: O(N), for visiting every node of the tree.
Auxiliary Space: O(N) for recursion call stack.

Previous
Next
Share your thoughts in the comments