Find maximum and minimum element in binary tree without using recursion or stack or queue - GeeksforGeeks

04 Aug, 2021
Given a binary tree. The task is to find out the maximum and minimum element in a binary tree without using recursion or stack or queue i.e, space complexity should be O(1). 
Examples: 
Input : 
                       12
                     /     \
                   13       10
                          /     \
                       14       15
                      /   \     /  \
                     21   24   22   23

Output : Max element : 24
         Min element : 10

Input : 
                       12
                     /     \
                  19        82
                 /        /     \
               41       15       95
                 \     /         /  \
                  2   21        7   16

Output : Max element : 95
         Min element : 2
Prerequisite : Inorder Tree Traversal without recursion and without stack
Approach : 1. Initialize current as root 2. Take to variable max and min 3. While current is not NULL 
If the current does not have left child Update variable max and min with current’s data if requiredGo to the right, i.e., current = current->right
Update variable max and min with current’s data if required
Go to the right, i.e., current = current->right
Else Make current as the right child of the rightmost node in current’s left subtreeGo to this left child, i.e., current = current->left
Make current as the right child of the rightmost node in current’s left subtree
Go to this left child, i.e., current = current->left
Below is the implementation of the above approach :  
C++
Java
Python3
C#
Javascript
// C++ program find maximum and minimum element#include <bits/stdc++.h>using namespace std; // A Tree nodestruct Node {    int key;    struct Node *left, *right;}; // Utility function to create a new nodeNode* newNode(int key){    Node* temp = new Node;    temp->key = key;    temp->left = temp->right = NULL;    return (temp);}  // Function to print a maximum and minimum element// in a tree without recursion without stackvoid printMinMax(Node* root){         if (root == NULL)    {        cout << "Tree is empty";        return;    }         Node* current = root;         Node* pre;         // Max variable for storing maximum value       int max_value = INT_MIN;         // Min variable for storing minimum value       int min_value = INT_MAX;              while (current != NULL)    {        // If left child does nor exists        if (current->left == NULL)        {            max_value = max(max_value, current->key);            min_value = min(min_value, current->key);                         current = current->right;        }        else        {               // Find the inorder predecessor of current            pre = current->left;            while (pre->right != NULL && pre->right !=                                                 current)                pre = pre->right;               // Make current as the right child            // of its inorder predecessor            if (pre->right == NULL)            {                pre->right = current;                current = current->left;            }               // Revert the changes made in the 'if' part to            // restore the original tree i.e., fix the            // right child of predecessor            else            {                pre->right = NULL;                                 max_value = max(max_value, current->key);                min_value = min(min_value, current->key);                             current = current->right;            } // End of if condition pre->right == NULL                     } // End of if condition current->left == NULL             } // End of while         // Finally print max and min value    cout << "Max Value is : " << max_value << endl;    cout << "Min Value is : " << min_value << endl;} // Driver Codeint main(){    /* 15      /  \    19   11        /  \       25   5      / \   / \    17  3  23  24     Let us create Binary Tree as shown    above */     Node* root = newNode(15);    root->left = newNode(19);    root->right = newNode(11);     root->right->left = newNode(25);    root->right->right = newNode(5);     root->right->left->left = newNode(17);    root->right->left->right = newNode(3);    root->right->right->left = newNode(23);    root->right->right->right = newNode(24);         // Function call for printing a max    // and min element in a tree    printMinMax(root);     return 0;}
// Java program find maximum and minimum elementclass GFG{ // A Tree nodestatic class Node{    int key;    Node left, right;}; // Utility function to create a new nodestatic Node newNode(int key){    Node temp = new Node();    temp.key = key;    temp.left = temp.right = null;    return (temp);}  // Function to print a maximum and minimum element// in a tree without recursion without stackstatic void printMinMax(Node root){         if (root == null)    {        System.out.print("Tree is empty");        return;    }         Node current = root;         Node pre;         // Max variable for storing maximum value    int max_value = Integer.MIN_VALUE;         // Min variable for storing minimum value    int min_value = Integer.MAX_VALUE;              while (current != null)    {        // If left child does nor exists        if (current.left == null)        {            max_value = Math.max(max_value, current.key);            min_value = Math.min(min_value, current.key);                         current = current.right;        }        else        {                 // Find the inorder predecessor of current            pre = current.left;            while (pre.right != null && pre.right !=                                                current)                pre = pre.right;                 // Make current as the right child            // of its inorder predecessor            if (pre.right == null)            {                pre.right = current;                current = current.left;            }                 // Revert the changes made in the 'if' part to            // restore the original tree i.e., fix the            // right child of predecessor            else            {                pre.right = null;                                 max_value = Math.max(max_value, current.key);                min_value = Math.min(min_value, current.key);                             current = current.right;            } // End of if condition pre.right == null                     } // End of if condition current.left == null             } // End of while         // Finally print max and min value    System.out.print("Max Value is : " + max_value + "\n");    System.out.print("Min Value is : " + min_value + "\n");} // Driver Codepublic static void main(String[] args){    /* 15    / \    19 11        / \    25 5    / \ / \    17 3 23 24     Let us create Binary Tree as shown    above */     Node root = newNode(15);    root.left = newNode(19);    root.right = newNode(11);     root.right.left = newNode(25);    root.right.right = newNode(5);     root.right.left.left = newNode(17);    root.right.left.right = newNode(3);    root.right.right.left = newNode(23);    root.right.right.right = newNode(24);         // Function call for printing a max    // and min element in a tree    printMinMax(root);}} // This code is contributed by Rajput-Ji
# Python program find maximum and minimum elementfrom sys import maxsize INT_MAX = maxsizeINT_MIN = -maxsize # A Tree nodeclass Node:    def __init__(self, key):        self.key = key        self.left = None        self.right = None # Function to print a maximum and minimum element# in a tree without recursion without stackdef printMinMax(root: Node):    if root is None:        print("Tree is empty")        return     current = root    pre = Node(0)     # Max variable for storing maximum value    max_value = INT_MIN     # Min variable for storing minimum value    min_value = INT_MAX     while current is not None:         # If left child does nor exists        if current.left is None:            max_value = max(max_value, current.key)            min_value = min(min_value, current.key)             current = current.right        else:             # Find the inorder predecessor of current            pre = current.left            while pre.right is not None and pre.right != current:                pre = pre.right             # Make current as the right child            # of its inorder predecessor            if pre.right is None:                pre.right = current                current = current.left             # Revert the changes made in the 'if' part to            # restore the original tree i.e., fix the            # right child of predecessor            else:                pre.right = None                max_value = max(max_value, current.key)                min_value = min(min_value, current.key)                 current = current.right             # End of if condition pre->right == NULL         # End of if condition current->left == NULL     # End of while     # Finally print max and min value    print("Max value is :", max_value)    print("Min value is :", min_value) # Driver Codeif __name__ == "__main__":     # /* 15    # / \    # 19 11    #     / \    # 25 5    # / \ / \    # 17 3 23 24     # Let us create Binary Tree as shown    # above */     root = Node(15)    root.left = Node(19)    root.right = Node(11)     root.right.left = Node(25)    root.right.right = Node(5)     root.right.left.left = Node(17)    root.right.left.right = Node(3)    root.right.right.left = Node(23)    root.right.right.right = Node(24)     # Function call for printing a max    # and min element in a tree    printMinMax(root) # This code is contributed by# sanjeev2552
// C# program find maximum and minimum elementusing System;class GFG{ // A Tree nodeclass Node{    public int key;    public Node left, right;}; // Utility function to create a new nodestatic Node newNode(int key){    Node temp = new Node();    temp.key = key;    temp.left = temp.right = null;    return (temp);} // Function to print a maximum and minimum element// in a tree without recursion without stackstatic void printMinMax(Node root){    if (root == null)    {        Console.Write("Tree is empty");        return;    }         Node current = root;         Node pre;         // Max variable for storing maximum value    int max_value = int.MinValue;         // Min variable for storing minimum value    int min_value = int.MaxValue;         while (current != null)    {        // If left child does nor exists        if (current.left == null)        {            max_value = Math.Max(max_value,                                 current.key);            min_value = Math.Min(min_value,                                 current.key);                         current = current.right;        }        else        {                 // Find the inorder predecessor of current            pre = current.left;            while (pre.right != null &&                   pre.right != current)                pre = pre.right;                 // Make current as the right child            // of its inorder predecessor            if (pre.right == null)            {                pre.right = current;                current = current.left;            }                 // Revert the changes made in the 'if' part to            // restore the original tree i.e., fix the            // right child of predecessor            else            {                pre.right = null;                                 max_value = Math.Max(max_value,                                     current.key);                min_value = Math.Min(min_value,                                         current.key);                             current = current.right;            } // End of if condition pre.right == null                     } // End of if condition current.left == null             } // End of while         // Finally print max and min value    Console.Write("Max Value is : " +                   max_value + "\n");    Console.Write("Min Value is : " +                   min_value + "\n");} // Driver Codepublic static void Main(String[] args){    /* 15    / \    19 11        / \    25 5    / \ / \    17 3 23 24     Let us create Binary Tree as shown    above */     Node root = newNode(15);    root.left = newNode(19);    root.right = newNode(11);     root.right.left = newNode(25);    root.right.right = newNode(5);     root.right.left.left = newNode(17);    root.right.left.right = newNode(3);    root.right.right.left = newNode(23);    root.right.right.right = newNode(24);         // Function call for printing a max    // and min element in a tree    printMinMax(root);}} // This code is contributed by PrinciRaj1992
<script> // Javascript program find maximum// and minimum element // A Tree nodeclass Node{    constructor()    {        this.key = 0;        this.left = null;        this.right = null;    }}; // Utility function to create a new nodefunction newNode(key){    var temp = new Node();    temp.key = key;    temp.left = temp.right = null;    return (temp);} // Function to print a maximum and minimum// element in a tree without recursion// without stackfunction printMinMax(root){    if (root == null)    {        document.write("Tree is empty");        return;    }         var current = root;    var pre;         // Max variable for storing maximum value    var max_value = -1000000000;         // Min variable for storing minimum value    var min_value = 1000000000;         while (current != null)    {                 // If left child does nor exists        if (current.left == null)        {            max_value = Math.max(max_value,                                 current.key);            min_value = Math.min(min_value,                                 current.key);                         current = current.right;        }        else        {                         // Find the inorder predecessor of current            pre = current.left;            while (pre.right != null &&                   pre.right != current)                pre = pre.right;                 // Make current as the right child            // of its inorder predecessor            if (pre.right == null)            {                pre.right = current;                current = current.left;            }                 // Revert the changes made in the 'if'            // part to restore the original tree            // i.e., fix the right child of predecessor            else            {                pre.right = null;                                 max_value = Math.max(max_value,                                     current.key);                min_value = Math.min(min_value,                                         current.key);                             current = current.right;            } // End of if condition pre.right == null                     } // End of if condition current.left == null             } // End of while         // Finally print max and min value    document.write("Max Value is : " +                   max_value + "<br>");    document.write("Min Value is : " +                   min_value + "<br>");} // Driver Code/* 15/ \19 11    / \25 5/ \ / \17 3 23 24Let us create Binary Tree as shownabove */var root = newNode(15);root.left = newNode(19);root.right = newNode(11);root.right.left = newNode(25);root.right.right = newNode(5);root.right.left.left = newNode(17);root.right.left.right = newNode(3);root.right.right.left = newNode(23);root.right.right.right = newNode(24); // Function call for printing a max// and min element in a treeprintMinMax(root); // This code is contributed by noob2000 </script>
Output : 
Max Value is : 25
Min Value is : 3
Time Complexity: O(N)Space complexity: O(1) 
Rajput-Ji
princiraj1992
sanjeev2552
noob2000
pankajsharmagfg
Inorder Traversal
Algorithms
Tree
Tree
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
DSA Sheet by Love Babbar
SCAN (Elevator) Disk Scheduling Algorithms
Rail Fence Cipher - Encryption and Decryption
Quadratic Probing in Hashing
Program for SSTF disk scheduling algorithm
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