Open In App

Find maximum among all right nodes in Binary Tree

Improve
Improve
Like Article
Like
Save
Share
Report

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

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<bits/stdc++.h>
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<Node*> 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<Node> 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<Node> q = new Queue<Node>();
        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.



Last Updated : 11 Mar, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads