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 <bits/stdc++.h> 
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:

Time Complexity : O(n)

My Personal Notes

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

C++

Java

Python3

C#

Recommended Posts: