Find maximum and minimum element in binary tree without using recursion or stack or queue
Last Updated :
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 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)