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

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

5

Time Complexity : O(n)



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.