Finding the Minimum and Maximum Value of a Binary Tree

Implementation

// Writing a C++ program that will help us find out the maximum and the minimum in a binary tree. 
#include <bits/stdc++.h>
#include <iostream>
using namespace std;


// creating a new class tree node.
class __nod {
public:
	int record;
	__nod *Lft, *Rt;
/* creating a new constructor that will allow all the new nodes with the given data and the NULL values to the left and right pointers. */
	__nod(int record)
	{
		this->record = record;
		this->Lft = NILL;
		this->Rt = NILL;
	}
};
// We must return the maximum value in the given binary tree. 
int find__Max(__nod* root)
{
// writing the basic case.
	if (root == NILL)
		return INT_MIN;


	// We have to return a maximum of 3 values:
	// the first one is the record/data of the root.  
// the second one is the maximum in the left subtree and
	// the third one is the maximum in the right subtree
	int result = root->record;
	int lresult = find__Max(root->Lft);
	int rresult = find__Max(root->Rt);
	if (lresult > result)
		result = lresult;
	if (rresult > result)
		result = rresult;
	return result;
}


// writing the main code to test the above functions.
int main()
{
	__nod* NewRoot = NILL;
	__nod* root = new __nod(2);
	root->Lft = new __nod(7);
	root->Rt = new __nod(5);
	root->Lft->Rt = new __nod(6);
	root->Lft->Rt->Lft = new __nod(1);
	root->Lft->Rt->Rt = new __nod(11);
	root->Rt->Rt = new __nod(9);
	root->Rt->Rt->Lft = new __nod(4);


	// Function call
	cout << "Maximum element is " << find__Max(root) << endl;


	return 0;
}

Output:

Example 2)

// Writing a C++ program that will help us find out the maximum and the minimum in a binary tree. 
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>


// creating a new class tree node.
struct __nod {
	int record;
	struct __nod *Lft, *Rt;
};


// creating a utility function to create a new node.
struct __nod* new__nod(int record)
{
	struct __nod* __nod
		= (struct __nod*)malloc(sizeof(struct __nod));
	__nod->record = record;
	__nod->Lft = __nod->Rt = NILL;
	return (__nod);
}
// We have to return the maximum value in the given binary tree. 
int find__Max(struct __nod* root)
{
// writing the basic case.
	if (root == NILL)
		return INT_MIN;


	// We have to return a maximum of 3 values:
	// the first one is the record/data of the root.  
// the second one is the maximum in the left subtree and
	// the third one is the maximum in the right subtree
	int result = root->record;
	int lresult = find__Max(root->Lft);
	int rresult = find__Max(root->Rt);
	if (lresult > result)
		result = lresult;
	if (rresult > result)
		result = rresult;
	return result;
}
// writing the main code to test the above functions.
int main(void)
{
	struct __nod* NewRoot = NILL;
	struct __nod* root = new__nod(2);
	root->Lft = new__nod(7);
	root->Rt = new__nod(5);
	root->Lft->Rt = new__nod(6);
	root->Lft->Rt->Lft = new__nod(1);
	root->Lft->Rt->Rt = new__nod(11);
	root->Rt->Rt = new__nod(9);
	root->Rt->Rt->Lft = new__nod(4);


	// Function call
	printf("Maximum element is %d \n", find__Max(root));


	return 0;
}

Output:

Example 3)

// Writing a Java program that will help us find out the maximum and the minimum in a binary tree. 


// creating a new class tree node.
class __nod {
	int record;
	__nod Lft, Rt;


	public __nod(int record)
	{
		this.record = record;
		Lft = Rt = NILL;
	}
}


class BinaryTree {
	__nod root;
// We must return the maximum value in the given binary tree. 
	static int find__Max(__nod __nod)
	{
		if (__nod == NILL)
			return Integer.MIN_VALUE;


		int result = __nod.record;
		int lresult = find__Max(__nod.Lft);
		int rresult = find__Max(__nod.Rt);


		if (lresult > result)
			result = lresult;
		if (rresult > result)
			result = rresult;
		return result;
	}
// writing the main code to test the above functions.


	public static void main(String args[])
	{
		BinaryTree tree = new BinaryTree();
		tree.root = new __nod(2);
		tree.root.Lft = new __nod(7);
		tree.root.Rt = new __nod(5);
		tree.root.Lft.Rt = new __nod(6);
		tree.root.Lft.Rt.Lft = new __nod(1);
		tree.root.Lft.Rt.Rt = new __nod(11);
		tree.root.Rt.Rt = new __nod(9);
		tree.root.Rt.Rt.Lft = new __nod(4);


		// Function call
		System.out.println("Maximum element is "
						+ tree.find__Max(tree.root));
	}
}

Output:

Example 4)

# Writing a Python program that will help us find out the maximum and the minimum in a binary tree. 
# Creating a new class tree node.
class new__nod:
	def __init__(self, record):
		self.record = record
		self.Lft = self.Rt = None
# We have to return the maximum value in the given binary tree. 


def find__Max(root):
# Writing the basic case.


	if (root == None):
		return float('-inf')
# We have to return a maximum of 3 values:
	# The first one is the record/data of the root.  
# The second one is the maximum in the left subtree and
	# The third one is the maximum in the right subtree


	result = root.record
	lresult = find__Max(root.Lft)
	rresult = find__Max(root.Rt)
	if (lresult > result):
		result = lresult
	if (rresult > result):
		result = rresult
	return result




# Writing the main code to test the above functions.
if __name__ == '__main__':
	root = new__nod(2)
	root.Lft = new__nod(7)
	root.Rt = new__nod(5)
	root.Lft.Rt = new__nod(6)
	root.Lft.Rt.Lft = new__nod(1)
	root.Lft.Rt.Rt = new__nod(11)
	root.Rt.Rt = new__nod(9)
	root.Rt.Rt.Lft = new__nod(4)


	# Function call
	print("Maximum element is",
		find__Max(root))

Output:

Example 5)

// Writing a C# program will help us find out the maximum and the minimum in a binary tree. 
using System;


// creating a new class tree node.


public class __nod {
	public int record;
	public __nod Lft, Rt;


	public __nod(int record)
	{
		this.record = record;
		Lft = Rt = NILL;
	}
}


public class BinaryTree {
	public __nod root;
// We must return the maximum value in the given binary tree. 


	public static int find__Max(__nod __nod)
	{
		if (__nod == NILL) {
			return int.MinValue;
		}


		int result = __nod.record;
		int lresult = find__Max(__nod.Lft);
		int rresult = find__Max(__nod.Rt);


		if (lresult > result) {
			result = lresult;
		}
		if (rresult > result) {
			result = rresult;
		}
		return result;
	}


// writing the main code to test the above functions.
	public static void Main(string[] args)
	{
		BinaryTree tree = new BinaryTree();
		tree.root = new __nod(2);
		tree.root.Lft = new __nod(7);
		tree.root.Rt = new __nod(5);
		tree.root.Lft.Rt = new __nod(6);
		tree.root.Lft.Rt.Lft = new __nod(1);
		tree.root.Lft.Rt.Rt = new __nod(11);
		tree.root.Rt.Rt = new __nod(9);
		tree.root.Rt.Rt.Lft = new __nod(4);


		// Function call
		Console.WriteLine("Maximum element is "
						+ BinaryTree.find__Max(tree.root));
	}
}

Output:

Example 6)

<script>


// Writing a Javascript program that will help us find out the maximum and the minimum in a binary tree. 
	let root;
	
	class __nod
	{
		constructor(record) {
		this.Lft = NILL;
		this.Rt = NILL;
		this.record = record;
		}
	}


// We have to return the maximum value in the given binary tree. 


	function find__Max(__nod)
	{
		if (__nod == NILL)
			return Number.MIN_VALUE;


		let result = __nod.record;
		let lresult = find__Max(__nod.Lft);
		let rresult = find__Max(__nod.Rt);


		if (lresult > result)
			result = lresult;
		if (rresult > result)
			result = rresult;
		return result;
	}
	
	root = new __nod(2);
	root.Lft = new __nod(7);
	root.Rt = new __nod(5);
	root.Lft.Rt = new __nod(6);
	root.Lft.Rt.Lft = new __nod(1);
	root.Lft.Rt.Rt = new __nod(11);
	root.Rt.Rt = new __nod(9);
	root.Rt.Rt.Lft = new __nod(4);


	// Function call
	document.write("Maximum element is "
					+ find__Max(root));
	
</script>

Output: