Skip to content
Related Articles

Related Articles

Find maximum and minimum element in binary tree without using recursion or stack or queue
  • Last Updated : 23 Jan, 2020

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 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 subtree
    • Go to this left child, i.e., current = current->left

Below is the implementation of the above approach :

C++






// C++ program find maximum and minimum element
#include <bits/stdc++.h>
using namespace std;
  
// A Tree node
struct Node {
    int key;
    struct Node *left, *right;
};
  
// Utility function to create a new node
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 stack
void 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 Code
int 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




// Java program find maximum and minimum element 
class GFG
  
// A Tree node 
static class Node
    int key; 
    Node left, right; 
}; 
  
// Utility function to create a new node 
static 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 stack 
static 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 Code 
public 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

Python3




# Python program find maximum and minimum element
from sys import maxsize
  
INT_MAX = maxsize
INT_MIN = -maxsize
  
# A Tree node
class 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 stack
def 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 Code
if __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#




// C# program find maximum and minimum element 
using System;
class GFG
  
// A Tree node 
class Node
    public int key; 
    public Node left, right; 
}; 
  
// Utility function to create a new node 
static 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 stack 
static 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 Code 
public 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

Output :

Max Value is : 25
Min Value is : 3

Space complexity: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :