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

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

<script>

    // JavaScript implementation to print maximum element
    // among all right child nodes

    // User defined node class
    class Node
    {
        constructor(key) {
           this.left = null;
           this.right = null;
           this.data = key;
        }
    }

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

    // Create binary tree
    // as shown below

    /*   7
                / \
               6   5
              / \ / \
              4 3 2  1  */

    let 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);

    document.write(maxOfRightElement(root));

</script>

Output:

5

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