# Find maximum among all right nodes in Binary Tree

• Difficulty Level : Basic
• Last Updated : 11 Mar, 2023

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

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 contributed 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`

## Javascript

 ``

Output

`5`

Complexity Analysis:

• Time Complexity : O(n)
• Auxiliary Space: O(n)

Iterative Approach(Using Level Order Traversal):
Follow the below steps to solve the above problem
1) Return -1 if root node is NULL or root->right node is NULL.
2) Perform Level Order Traversal and check at each node if right node is exist then store the maximum of ans and current->node->right node data in ans.
3) Finally after completely traversing return the res.

Below is the implementation of above approach:

## C++

 `// Iterative Approach to solve this problem``// C++ code for above approach``// This code is contributed by Yash Agarwal(yashagarwal2852002)``#include``using` `namespace` `std;` `// a binary tree node``struct` `Node{``    ``int` `data;``    ``Node* left;``    ``Node* right;``    ``Node(``int` `data){``        ``this``->data = data;``        ``this``->left = NULL;``        ``this``->right = NULL;``    ``}``};` `// utility function to create a new tree node``Node* newNode(``int` `data){``    ``return` `new` `Node(data);``}` `// Function to find maximum element``// among all right child nodes using``// Level Order 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)  ``return` `-1;``    ``queue q;``    ``q.push(root);``    ``while``(!q.empty()){``        ``Node* front_node = q.front();``        ``q.pop();``        ``if``(front_node->left != NULL){``            ``q.push(front_node->left);``        ``}``        ``if``(front_node->right != NULL){``            ``q.push(front_node->right);``            ``res = max(res, front_node->right->data);``        ``}``    ``}``    ``return` `res;``}` `// 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;``}``// THIS CODE IS CONTRIBUTED BY YASH AGARWAL(YASHAGARWAL2852002)`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `Node {``  ``public` `int` `data;``  ``public` `Node left, right;``  ``public` `Node(``int` `data) {``    ``this``.data = data;``    ``left = right = ``null``;``  ``}``}` `class` `GFG {``  ``// Function to find maximum element``  ``// among all right child nodes using``  ``// Level Order Traversal``  ``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``)``      ``return` `-``1``;` `    ``Queue q = ``new` `LinkedList<>();``    ``q.add(root);` `    ``while` `(!q.isEmpty()) {``      ``Node front_node = q.poll();` `      ``if` `(front_node.left != ``null``) {``        ``q.add(front_node.left);``      ``}` `      ``if` `(front_node.right != ``null``) {``        ``q.add(front_node.right);``        ``res = Math.max(res, front_node.right.data);``      ``}``    ``}` `    ``return` `res;``  ``}` `  ``// Driver Code``  ``static` `public` `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 contributed by codebraxnzt`

## Python

 `# Iterative approach to solve self problem``# Python code for the above approach``# a binary 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):``    ``return` `Node(data)` `# function to find maximum element``# among all right child nodes using``# Level Order Traversal``def` `maxOfRightElement(root):``    ``# temp variable``    ``res ``=` `-``10000000``    ` `    ``# if tree is empty``    ``if``(root ``is` `None``):``        ``return` `-``1``    ` `    ``# if right child exists``    ``if``(root.right ``is` `None``):``        ``return` `-``1``    ``q ``=` `[]``    ``q.append(root)``    ``while``(``len``(q) > ``0``):``        ``front_node ``=` `q.pop(``0``)``        ``if``(front_node.left ``is` `not` `None``):``            ``q.append(front_node.left)``        ``if``(front_node.right ``is` `not` `None``):``            ``q.append(front_node.right)``            ``res ``=` `max``(res, front_node.right.data)``    ``return` `res`  `# driver program to test above function``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))`

## C#

 `// C# code for iterative approach to solve this problem``// This code is contributed by ChatGPT` `using` `System;``using` `System.Collections.Generic;` `// A binary tree node``class` `Node {``    ``public` `int` `data;``    ``public` `Node left, right;``    ``public` `Node(``int` `data)``    ``{``        ``this``.data = data;``        ``left = right = ``null``;``    ``}``}` `class` `GFG { ``// Function to find maximum element``    ``// among all right child nodes using``    ``// Level Order Traversal``    ``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``)``            ``return` `-1;` `        ``Queue q = ``new` `Queue();``        ``q.Enqueue(root);` `        ``while` `(q.Count > 0) {``            ``Node front_node = q.Dequeue();` `            ``if` `(front_node.left != ``null``) {``                ``q.Enqueue(front_node.left);``            ``}` `            ``if` `(front_node.right != ``null``) {``                ``q.Enqueue(front_node.right);``                ``res = Math.Max(res, front_node.right.data);``            ``}``        ``}` `        ``return` `res;``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main()``    ``{``        ``// 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));``    ``}``}`

## Javascript

 `// JavaScript implementation of above approach``// a binary tree node``class Node{``    ``constructor(data){``        ``this``.data = data;``        ``this``.left = ``null``;``        ``this``.right = ``null``;``    ``}``}` `// utility functionto create a new node``function` `newNode(data){``    ``return` `new` `Node(data);``}` `// Function to find maximum element``// among all right child nodes using``// Level Order Traversal``function` `maxOfRightElement(root){``    ``// temp variable``    ``let res = Number.MIN_VALUE;``    ` `    ``// if tree is empty``    ``if``(root == ``null``) ``return` `-1;``    ` `    ``// if right child exists``    ``if``(root.right == ``null``) ``return` `-1;``    ``let q = [];``    ``q.push(root);``    ``while``(q.length > 0){``        ``let front_node = q.shift();``        ``if``(front_node.left != ``null``) q.push(front_node.left);``        ``if``(front_node.right != ``null``){``            ``q.push(front_node.right)``            ``res = Math.max(res, front_node.right.data);``        ``}``    ``}``    ``return` `res;``}` `// driver code to test above function``// Create binary tree``// as shown below` `/*   7``    ``/ \``   ``6   5``  ``/ \ / \``  ``4 3 2 1  */``  ``let 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);``  ` `  ``console.log(maxOfRightElement(root));`

Output

`5`

Time Complexity : O(N), where N is the number of nodes.
Auxiliary Space: O(N), due to queue data structure.

My Personal Notes arrow_drop_up