Find maximum (or minimum) in Binary Tree - GeeksforGeeks

14 Feb, 2022
Given a Binary Tree, find the maximum(or minimum) element in it. For example, maximum in the following Binary Tree is 9. 
 
In Binary Search Tree, we can find maximum by traversing right pointers until we reach the rightmost node. But in Binary Tree, we must visit every node to figure out maximum. So the idea is to traverse the given tree and for every node return maximum of 3 values. 
Node’s data.Maximum in node’s left subtree.Maximum in node’s right subtree.
Node’s data.
Maximum in node’s left subtree.
Maximum in node’s right subtree.
Below is the implementation of above approach. 
C++
C
Java
Python3
C#
Javascript
// C++ program to find maximum and// minimum in a Binary Tree#include <bits/stdc++.h>#include <iostream>using namespace std; // A tree nodeclass Node {public:    int data;    Node *left, *right;     /* Constructor that allocates a new    node with the given data and NULL    left and right pointers. */    Node(int data)    {        this->data = data;        this->left = NULL;        this->right = NULL;    }}; // Returns maximum value in a given// Binary Treeint findMax(Node* root){    // Base case    if (root == NULL)        return INT_MIN;     // Return maximum of 3 values:    // 1) Root's data 2) Max in Left Subtree    // 3) Max in right subtree    int res = root->data;    int lres = findMax(root->left);    int rres = findMax(root->right);    if (lres > res)        res = lres;    if (rres > res)        res = rres;    return res;} // Driver Codeint main(){    Node* NewRoot = NULL;    Node* root = new Node(2);    root->left = new Node(7);    root->right = new Node(5);    root->left->right = new Node(6);    root->left->right->left = new Node(1);    root->left->right->right = new Node(11);    root->right->right = new Node(9);    root->right->right->left = new Node(4);     // Function call    cout << "Maximum element is " << findMax(root) << endl;     return 0;} // This code is contributed by// rathbhupendra
// C program to find maximum and minimum in a Binary Tree#include <limits.h>#include <stdio.h>#include <stdlib.h> // A tree nodestruct Node {    int data;    struct Node *left, *right;}; // A utility function to create a new nodestruct Node* newNode(int data){    struct Node* node        = (struct Node*)malloc(sizeof(struct Node));    node->data = data;    node->left = node->right = NULL;    return (node);} // Returns maximum value in a given Binary Treeint findMax(struct Node* root){    // Base case    if (root == NULL)        return INT_MIN;     // Return maximum of 3 values:    // 1) Root's data 2) Max in Left Subtree    // 3) Max in right subtree    int res = root->data;    int lres = findMax(root->left);    int rres = findMax(root->right);    if (lres > res)        res = lres;    if (rres > res)        res = rres;    return res;} // Driver codeint main(void){    struct Node* NewRoot = NULL;    struct Node* root = newNode(2);    root->left = newNode(7);    root->right = newNode(5);    root->left->right = newNode(6);    root->left->right->left = newNode(1);    root->left->right->right = newNode(11);    root->right->right = newNode(9);    root->right->right->left = newNode(4);     // Function call    printf("Maximum element is %d \n", findMax(root));     return 0;}
// Java code to Find maximum (or minimum) in// Binary Tree // A binary tree nodeclass Node {    int data;    Node left, right;     public Node(int data)    {        this.data = data;        left = right = null;    }} class BinaryTree {    Node root;     // Returns the max value in a binary tree    static int findMax(Node node)    {        if (node == null)            return Integer.MIN_VALUE;         int res = node.data;        int lres = findMax(node.left);        int rres = findMax(node.right);         if (lres > res)            res = lres;        if (rres > res)            res = rres;        return res;    }     /* Driver code */    public static void main(String args[])    {        BinaryTree tree = new BinaryTree();        tree.root = new Node(2);        tree.root.left = new Node(7);        tree.root.right = new Node(5);        tree.root.left.right = new Node(6);        tree.root.left.right.left = new Node(1);        tree.root.left.right.right = new Node(11);        tree.root.right.right = new Node(9);        tree.root.right.right.left = new Node(4);         // Function call        System.out.println("Maximum element is "                           + tree.findMax(tree.root));    }} // This code is contributed by Kamal Rawal
# Python3 program to find maximum# and minimum in a Binary Tree # A class to create a new node  class newNode:    def __init__(self, data):        self.data = data        self.left = self.right = None # Returns maximum value in a# given Binary Tree  def findMax(root):     # Base case    if (root == None):        return float('-inf')     # Return maximum of 3 values:    # 1) Root's data 2) Max in Left Subtree    # 3) Max in right subtree    res = root.data    lres = findMax(root.left)    rres = findMax(root.right)    if (lres > res):        res = lres    if (rres > res):        res = rres    return res  # Driver Codeif __name__ == '__main__':    root = newNode(2)    root.left = newNode(7)    root.right = newNode(5)    root.left.right = newNode(6)    root.left.right.left = newNode(1)    root.left.right.right = newNode(11)    root.right.right = newNode(9)    root.right.right.left = newNode(4)     # Function call    print("Maximum element is",          findMax(root)) # This code is contributed by PranchalK
// C# code to Find maximum (or minimum) in// Binary Treeusing System; // A binary tree nodepublic class Node {    public int data;    public Node left, right;     public Node(int data)    {        this.data = data;        left = right = null;    }} public class BinaryTree {    public Node root;     // Returns the max value in a binary tree    public static int findMax(Node node)    {        if (node == null) {            return int.MinValue;        }         int res = node.data;        int lres = findMax(node.left);        int rres = findMax(node.right);         if (lres > res) {            res = lres;        }        if (rres > res) {            res = rres;        }        return res;    }     /* Driver code */    public static void Main(string[] args)    {        BinaryTree tree = new BinaryTree();        tree.root = new Node(2);        tree.root.left = new Node(7);        tree.root.right = new Node(5);        tree.root.left.right = new Node(6);        tree.root.left.right.left = new Node(1);        tree.root.left.right.right = new Node(11);        tree.root.right.right = new Node(9);        tree.root.right.right.left = new Node(4);         // Function call        Console.WriteLine("Maximum element is "                          + BinaryTree.findMax(tree.root));    }} // This code is contributed by Shrikant13
<script>     // Javascript code to Find maximum (or minimum)    // in Binary Tree         let root;         class Node    {        constructor(data) {           this.left = null;           this.right = null;           this.data = data;        }    }       // Returns the max value in a binary tree    function findMax(node)    {        if (node == null)            return Number.MIN_VALUE;           let res = node.data;        let lres = findMax(node.left);        let rres = findMax(node.right);           if (lres > res)            res = lres;        if (rres > res)            res = rres;        return res;    }         root = new Node(2);    root.left = new Node(7);    root.right = new Node(5);    root.left.right = new Node(6);    root.left.right.left = new Node(1);    root.left.right.right = new Node(11);    root.right.right = new Node(9);    root.right.right.left = new Node(4);     // Function call    document.write("Maximum element is "                       + findMax(root));     </script>
Maximum element is 11

 
Similarly, we can find the minimum element in a Binary tree by comparing three values. Below is the function to find a minimum in Binary Tree. 
 
C
Java
Python3
C#
Javascript
C++
// Returns minimum value in a given Binary Treeint findMin(struct Node* root){    // Base case    if (root == NULL)      return INT_MAX;     // Return minimum of 3 values:    // 1) Root's data 2) Max in Left Subtree    // 3) Max in right subtree    int res = root->data;    int lres = findMin(root->left);    int rres = findMin(root->right);    if (lres < res)      res = lres;    if (rres < res)      res = rres;    return res;}
// Returns the min value in a binary treestatic int findMin(Node node){    if (node == null)        return Integer.MAX_VALUE;     int res = node.data;    int lres = findMin(node.left);    int rres = findMin(node.right);     if (lres < res)        res = lres;    if (rres < res)        res = rres;    return res;}
# Returns the min value in a binary tree def find_min_in_BT(root):    if root is None:        return float('inf')    res = root.data    lres = find_min_in_BT(root.leftChild)    rres = find_min_in_BT(root.rightChild)    if lres < res:        res = lres    if rres < res:        res = rres    return res # This code is contributed by Subhajit Nandi
// Returns the min value in a binary treepublic static int findMin(Node node){    if (node == null)        return int.MaxValue;     int res = node.data;    int lres = findMin(node.left);    int rres = findMin(node.right);     if (lres < res)        res = lres;    if (rres < res)        res = rres;    return res;} // This code is contributed by Code_Mech
<script>       // Returns the min value in a binary tree      function findMin(node) {        if (node == null) return 2147483647;         var res = node.data;        var lres = findMin(node.left);        var rres = findMin(node.right);         if (lres < res) res = lres;        if (rres < res) res = rres;        return res;      }       </script>
int findMin(Node *root)    {        //code        if(root==NULL)     {         return INT_MAX;     }       int res=root->data;       int left=findMin(root->left);       int right=findMin(root->right);       if(left<res)       {           res=left;       }       if(right<res)       {           res=right;       }       return res;    }
Complexity Analysis:
Time Complexity: O(N).In the recursive function calls, every node of the tree is processed once and hence the complexity due to the function is O(N) if there are total N nodes in the tree. Therefore, the time complexity is O(N).
Space Complexity: O(N).Recursive call is happening. The every node is processed once and considering the stack space, the space complexity will be O(N). 
YouTubeGeeksforGeeks501K subscribersFind maximum (or minimum) in Binary Tree | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.More videosMore videosYou're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 6:29•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=vpMe2aZM6Kg" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
?list=PLqM7alHXFySHCXD7r1J0ky9Zg_GBB1dbk  
This article is contributed by Himanshu Gupta. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
 
shrikanth13
PranchalKatiyar
Code_Mech
rathbhupendra
Akanksha_Rai
SubhajitNandi
muskan_garg
mukesh07
rdtank
abhirami2262
akshitsaxenaa09
prasanna1995
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
AVL Tree | Set 1 (Insertion)
Inorder Tree Traversal without Recursion
Binary Tree | Set 3 (Types of Binary Tree)
Write a Program to Find the Maximum Depth or Height of a Tree
Binary Tree | Set 2 (Properties)
Decision Tree
A program to check if a binary tree is BST or not