# Finding the Maximum Element in a Binary Tree

### Implementation

```
// Creating a C++ program to excavate the minimum and maximum in a given binary tree.
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
// creating a new 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 findMax(__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 res = root->record;
int lres = findMax(root->Lft);
int rres = findMax(root->Rt);
if (lres > res)
res = lres;
if (rres > res)
res = rres;
return res;
}
// 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 " << findMax(root) << endl;
return 0;
}
```

**Output:**

**Example 2)**

```
// Creating a C# program to excavate the minimum and maximum in a given binary tree.
using System;
// creating a new 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 findMax(__nod __nod)
{
if (__nod == NILL) {
return int.MinValue;
}
int res = __nod.record;
int lres = findMax(__nod.Lft);
int rres = findMax(__nod.Rt);
if (lres > res) {
res = lres;
}
if (rres > res) {
res = rres;
}
return res;
}
// 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.findMax(tree.root));
}
}
```

**Output:**

**Example 3)**

```
// Creating a C program to excavate the minimum and maximum in a given binary tree.
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
// creating a new tree node.
struct __nod {
int record;
struct __nod *Lft, *Rt;
};
// creating a utility function that will help us in creating 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 must return the maximum value in the given binary tree.
int findMax(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 res = root->record;
int lres = findMax(root->Lft);
int rres = findMax(root->Rt);
if (lres > res)
res = lres;
if (rres > res)
res = rres;
return res;
}
// 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", findMax(root));
return 0;
}
```

**Output:**

**Example 4)**

```
// Creating a Java program to excavate the minimum and maximum in a given binary tree.
// creating a new 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 findMax(__nod __nod)
{
if (__nod == NILL)
return Integer.MIN_VALUE;
int res = __nod.record;
int lres = findMax(__nod.Lft);
int rres = findMax(__nod.Rt);
if (lres > res)
res = lres;
if (rres > res)
res = rres;
return res;
}
// 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.findMax(tree.root));
}
}
```

**Output:**