# Find maximum among all right nodes in Binary Tree

Given a Binary Tree. The task is to find the maximum value among all of the right child nodes of the Binary Tree.

Note: If the tree does not contains any right child node or is empty, print -1.

Examples:

```Input :
7
/    \
6       5
/ \     / \
4  3     2  1
Output : 5
All possible right child nodes are: {3, 5, 1}
out of which 5 is of the maximum value.

Input :
1
/    \
2       3
/       / \
4       5   6
\    /  \
7  8    9
Output : 9
```

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

The idea is to recursively traverse the tree with inorder traversal and for every node:

• Check if the right child node exists.
• If yes, store it’s value in a temporary variable.
• Return the maximum among (current node’s right child node’s value, recursive call for left subtree, recursive call for right subtree).

Below is the implementation of the above approach:

## C++

 `// CPP program to print maximum element ` `// among all right child nodes ` `#include ` `using` `namespace` `std; ` ` `  `// A Binary Tree Node ` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node *left, *right; ` `}; ` ` `  `// Utility function to create a new tree node ` `Node* newNode(``int` `data) ` `{ ` `    ``Node* temp = ``new` `Node; ` `    ``temp->data = data; ` `    ``temp->left = temp->right = NULL; ` `    ``return` `temp; ` `} ` ` `  `// Function to find maximum element ` `// among all right child nodes using ` `// Inorder Traversal ` `int` `maxOfRightElement(Node* root) ` `{ ` `    ``// Temp variable ` `    ``int` `res = INT_MIN; ` ` `  `    ``// If tree is empty ` `    ``if` `(root == NULL) ` `        ``return` `-1; ` ` `  `    ``// If right child exists ` `    ``if` `(root->right != NULL) ` `        ``res = root->right->data; ` ` `  `    ``// Return maximum of three values ` `    ``// 1) Recursive max in right subtree ` `    ``// 2) Value in right child node ` `    ``// 3) Recursive max in left subtree ` `    ``return` `max({ maxOfRightElement(root->right), ` `                 ``res, ` `                 ``maxOfRightElement(root->left) }); ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Create binary tree ` `    ``// as shown below ` ` `  `    ``/*   7 ` `        ``/ \ ` `       ``6   5 ` `      ``/ \ / \ ` `      ``4 3 2 1  */` `    ``Node* root = newNode(7); ` `    ``root->left = newNode(6); ` `    ``root->right = newNode(5); ` `    ``root->left->left = newNode(4); ` `    ``root->left->right = newNode(3); ` `    ``root->right->left = newNode(2); ` `    ``root->right->right = newNode(1); ` ` `  `    ``cout << maxOfRightElement(root); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to print maximum element  ` `// among all right child nodes ` `import` `java.io.*;  ` `import` `java.util.*; ` ` `  `// User defined node class ` `class` `Node { ` `      ``int` `data; ` `      ``Node left, right; ` `      ``// Constructor to create a new tree node ` `      ``Node(``int` `key) ` `      ``{ ` `           ``data = key; ` `           ``left = right = ``null``; ` `      ``} ` `} ` `class` `GFG { ` `      ``static` `int` `maxOfRightElement(Node root) ` `      ``{ ` `             ``// Temp variable ` `             ``int` `res = Integer.MIN_VALUE; ` ` `  `             ``// If tree is empty  ` `             ``if` `(root == ``null``) ` `                 ``return` `-``1``; ` `              `  `              ``// If right child exists ` `              ``if` `(root.right != ``null``) ` `                  ``res = root.right.data; ` ` `  `              ``// Return maximum of three values  ` `              ``// 1) Recursive max in right subtree ` `              ``// 2) Value in right child node  ` `              ``// 3) Recursive max in left subtree ` `              ``return` `Math.max(maxOfRightElement(root.right), ` `                     ``Math.max(res,maxOfRightElement(root.left))); ` `      ``} ` `      ``// Driver code ` `      ``public` `static` `void` `main(String args[]) ` `      ``{ ` `           ``// Create binary tree ` `          ``// as shown below ` ` `  `          ``/*   7 ` `              ``/ \ ` `             ``6   5 ` `            ``/ \ / \ ` `            ``4 3 2  1  */`  `      `  `          ``Node root = ``new` `Node(``7``); ` `          ``root.left = ``new` `Node(``6``); ` `          ``root.right = ``new` `Node(``5``); ` `          ``root.left.left = ``new` `Node(``4``); ` `          ``root.left.right = ``new` `Node(``3``); ` `          ``root.right.left = ``new` `Node(``2``); ` `          ``root.right.right = ``new` `Node(``1``); ` `  `  `          ``System.out.println(maxOfRightElement(root)); ` `       ``} ` `} ` `// This code is contibuted by rachana soma  `

## Python3

 `# Python3 program to print maximum element ` `# among all right child nodes ` ` `  `# Tree node  ` `class` `Node:  ` `    ``def` `__init__(``self``, data):  ` `        ``self``.data ``=` `data  ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` ` `  `# Utility function to create a new tree node ` `def` `newNode(data): ` ` `  `    ``temp ``=` `Node(``0``) ` `    ``temp.data ``=` `data ` `    ``temp.left ``=` `temp.right ``=` `None` `    ``return` `temp ` ` `  `# Function to find maximum element ` `# among all right child nodes using ` `# Inorder Traversal ` `def` `maxOfRightElement(root): ` ` `  `    ``# Temp variable ` `    ``res ``=` `-``999999` ` `  `    ``# If tree is empty ` `    ``if` `(root ``=``=` `None``): ` `        ``return` `-``1` ` `  `    ``# If right child exists ` `    ``if` `(root.right !``=` `None``): ` `        ``res ``=` `root.right.data ` ` `  `    ``# Return maximum of three values ` `    ``# 1) Recursive max in right subtree ` `    ``# 2) Value in right child node ` `    ``# 3) Recursive max in left subtree ` `    ``return` `max``( maxOfRightElement(root.right), ` `                ``res, ` `                ``maxOfRightElement(root.left) ) ` ` `  `# Driver Code ` ` `  `# Create binary tree ` `# as shown below ` `#     7 ` `# / \ ` `# 6 5 ` `# / \ / \ ` `# 4 3 2 1  ` `root ``=` `newNode(``7``) ` `root.left ``=` `newNode(``6``) ` `root.right ``=` `newNode(``5``) ` `root.left.left ``=` `newNode(``4``) ` `root.left.right ``=` `newNode(``3``) ` `root.right.left ``=` `newNode(``2``) ` `root.right.right ``=` `newNode(``1``) ` ` `  `print` `(maxOfRightElement(root)) ` ` `  `# This code is contributed by Arnab Kundu `

## C#

 `// C# implementation to print maximum element  ` `// among all right child nodes  ` `using` `System; ` ` `  `// User defined node class  ` `public` `class` `Node  ` `{  ` `    ``public` `int` `data;  ` `    ``public` `Node left, right;  ` `     `  `    ``// Constructor to create a new tree node  ` `    ``public` `Node(``int` `key)  ` `    ``{  ` `        ``data = key;  ` `        ``left = right = ``null``;  ` `    ``}  ` `}  ` ` `  `public` `class` `GFG  ` `{  ` `    ``static` `int` `maxOfRightElement(Node root)  ` `    ``{  ` `            ``// Temp variable  ` `            ``int` `res = ``int``.MinValue;  ` ` `  `            ``// If tree is empty  ` `            ``if` `(root == ``null``)  ` `                ``return` `-1;  ` `             `  `            ``// If right child exists  ` `            ``if` `(root.right != ``null``)  ` `                ``res = root.right.data;  ` ` `  `            ``// Return maximum of three values  ` `            ``// 1) Recursive max in right subtree  ` `            ``// 2) Value in right child node  ` `            ``// 3) Recursive max in left subtree  ` `            ``return` `Math.Max(maxOfRightElement(root.right),  ` `                    ``Math.Max(res,maxOfRightElement(root.left)));  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main(String []args)  ` `    ``{  ` `        ``// Create binary tree  ` `        ``// as shown below  ` ` `  `        ``/* 7  ` `            ``/ \  ` `            ``6 5  ` `            ``/ \ / \  ` `            ``4 3 2 1 */` `     `  `        ``Node root = ``new` `Node(7);  ` `        ``root.left = ``new` `Node(6);  ` `        ``root.right = ``new` `Node(5);  ` `        ``root.left.left = ``new` `Node(4);  ` `        ``root.left.right = ``new` `Node(3);  ` `        ``root.right.left = ``new` `Node(2);  ` `        ``root.right.right = ``new` `Node(1);  ` ` `  `        ``Console.WriteLine(maxOfRightElement(root));  ` `    ``}  ` `}  ` ` `  `// This code is contributed 29AjayKumar `

Output:

```5
```

Time Complexity : 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.

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.