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
- Make current as the right child of the rightmost
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 |
Javascript
<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)