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

• Difficulty Level : Hard
• 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```

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 ``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

 ``

Output :

```Max Value is : 25
Min Value is : 3```

Time Complexity: O(N)
Space complexity: O(1)

My Personal Notes arrow_drop_up