Find maximum and minimum element in binary tree without using recursion or stack or queue
Last Updated :
11 Jul, 2025
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 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
# 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# 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
<script>
// Javascript program find maximum
// and minimum element
// A Tree node
class Node
{
constructor()
{
this.key = 0;
this.left = null;
this.right = null;
}
};
// Utility function to create a new node
function 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 stack
function 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 24
Let us create Binary Tree as shown
above */
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 tree
printMinMax(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)
Similar Reads
Find the node with maximum value in a Binary Search Tree using recursion Given a Binary Search Tree, the task is to find the node with maximum value. Examples: Input: Output: 22 Approach: Just traverse the node from root to right recursively until right is NULL. The node whose right is NULL is the node with the maximum value. Below is the implementation of the above appr
7 min read
Find the node with minimum value in a Binary Search Tree using recursion Given the root of a Binary Search Tree, the task is to find the minimum valued element in this given BST.Examples: Input: Output: 1Explanation: The minimum element in the given BST is 1.Input: Output: 2Explanation: The minimum element in the given BST is 2.Approach:The idea is to recursively travers
6 min read
Sum and Product of maximum and minimum element in Binary Tree Given a Binary Tree. The task is to find the sum and product of the maximum and minimum elements in it. For example, sum of the maximum and minimum elements in the following binary tree is 10 and the product is 9. The idea is to traverse the tree and find the maximum and minimum elements in the tree
12 min read
Van Emde Boas Tree | Set 2 | Insertion, Find, Minimum and Maximum Queries It is highly recommended to see previous articles on Van Emde Boas Tree first. Procedure for Insert : If no keys are present in the tree then simply assign minimum and maximum of the tree to the key.Otherwise we will go deeper in the tree and do the following:If the key we want to insert is less tha
15+ min read
Leaf nodes from Preorder of a Binary Search Tree (Using Recursion) Given Preorder traversal of a Binary Search Tree. Then the task is to print leaf nodes of the Binary Search Tree from the given preorder.Examples : Input : preorder[] = {890, 325, 290, 530, 965};Output : 290 530 965Explanation: Below is the representation of BST using preorder array. Approach:To ide
8 min read
Find the minimum Sub-tree with target sum in a Binary search tree Given a binary tree and a target, find the number of nodes in the minimum sub-tree with the given sum equal to the target which is also a binary search tree. Examples: Input: 13 / \ 5 23 / \ / \ N 17 N N / 16Target: 38Output: 3Explanation: 5, 17, 16 is the smallest subtree with length 3. Input: 7 /
9 min read