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; } |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
Output:
5
Time Complexity : O(n)
Recommended Posts:
- Maximum sum of nodes in Binary tree such that no two are adjacent
- Sum of nodes at maximum depth of a Binary Tree
- Sum of nodes at maximum depth of a Binary Tree | Set 2
- Maximum sum of nodes in Binary tree such that no two are adjacent | Dynamic Programming
- Sum of nodes at maximum depth of a Binary Tree | Iterative Approach
- Maximum length cycle that can be formed by joining two nodes of a binary tree
- Minimum and maximum node that lies in the path connecting two nodes in a Binary Tree
- Find distance between two nodes of a Binary Tree
- Find sum of all nodes of the given perfect binary tree
- Queries to find distance between two nodes of a Binary tree
- Find height of a special binary tree whose leaf nodes are connected
- Queries to find distance between two nodes of a Binary tree - O(logn) method
- Find maximum level sum in Binary Tree
- Find maximum vertical sum in binary tree
- Find maximum (or minimum) in Binary Tree
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.
