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






                        filter_none









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







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# 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 



















                        chevron_right







                        filter_none









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







                        filter_none











Output:


5





Time Complexity : O(n)



          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
gfg_sal_gfg
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.