Sum and Product of maximum and minimum element in Binary Tree

Given a Binary Tree. The task is to find the sum and product of maximum and minimum element in it.

For example, sum of the maximum and minimum element in the following Binary Tree is 10 and the product is 9.

The idea is to traverse the tree and find the maximum and minimum elements in the tree and print their product and sum.



To find the maximum element in the Binary Tree, recursively traverse the tree and return the maximum of below three:

  1. Current Node’s data.
  2. Maximum in node’s left subtree.
  3. Maximum in node’s right subtree.

Similarly, we can find the minimum element in the Binary tree by comparing three values.

Below program illiustrate the above approach:

CPP

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find sum and product of 
// maximum and minimum in a Binary Tree 
#include<bits/stdc++.h> 
#include<iostream>
using namespace std; 
  
// A tree node 
class Node
{ 
    public:
    int data; 
    Node *left, *right; 
      
    /* Constructor that allocates 
    a new node with the given data
    and NULL left and right pointers. */
    Node(int data)
    {
        this->data = data;
        this->left = NULL;
        this->right = NULL;
    }
}; 
  
  
// Function to return minimum value 
// in a given Binary Tree 
int findMin(Node* root) 
{ 
    // Base case 
    if (root == NULL) 
        return INT_MAX; 
  
    // Return minimum of 3 values: 
    // 1) Root's data 2) Max in Left Subtree 
    // 3) Max in right subtree 
    int res = root->data; 
    int lres = findMin(root->left); 
    int rres = findMin(root->right); 
    if (lres < res) 
        res = lres; 
    if (rres < res) 
        res = rres; 
    return res; 
} 
  
// Function to returns maximum value 
// in a given Binary Tree 
int findMax(Node* root) 
{ 
    // Base case 
    if (root == NULL) 
        return INT_MIN; 
  
    // Return maximum of 3 values: 
    // 1) Root's data 2) Max in Left Subtree 
    // 3) Max in right subtree 
    int res = root->data; 
    int lres = findMax(root->left); 
    int rres = findMax(root->right); 
      
    if (lres > res) 
        res = lres; 
    if (rres > res) 
        res = rres; 
    return res; 
} 
  
// Function to find sum of max and min 
// elements in the Binary Tree 
int findSum(int max , int min) 
{ 
    return max + min; 
} 
  
// Function to find product of max and min 
// elements in the Binary Tree 
int findProduct(int max, int min) 
{ 
    return max*min; 
} 
  
// Driver Code 
int main() 
{ 
    // Create Binary Tree 
    Node* NewRoot = NULL; 
    Node* root = new Node(2); 
    root->left = new Node(7); 
    root->right = new Node(5); 
    root->left->right = new Node(6); 
    root->left->right->left = new Node(1); 
    root->left->right->right = new Node(11); 
    root->right->right = new Node(9); 
    root->right->right->left = new Node(4); 
      
    int max = findMax(root); 
    int min = findMin(root); 
      
    cout << "Sum of Maximum and Minimum element is " << 
           findSum(max,min); 
    cout << "\nProduct of Maximum and Minimum element is " << 
            findProduct(max,min); 
    return 0; 
} 
  
// This code is contributed by rathbhupendra

chevron_right






                        filter_none









C














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// C program to find sum and product of  


// maximum and minimum in a Binary Tree 


#include <limits.h> 


#include <stdio.h> 


#include <stdlib.h> 


  


// A tree node 


struct Node { 


    int data; 


    struct Node *left, *right; 


}; 


  


// A utility function to create a new node 


struct Node* newNode(int data) 


{ 


    struct Node* node = (struct Node*) 


        malloc(sizeof(struct Node)); 


    node->data = data; 


    node->left = node->right = NULL; 


    return (node); 


} 


  


// Function to return minimum value 


// in a given Binary Tree 


int findMin(struct Node* root) 


{ 


    // Base case 


    if (root == NULL) 


        return INT_MAX; 


  


    // Return minimum of 3 values: 


    // 1) Root's data 2) Max in Left Subtree 


    // 3) Max in right subtree 


    int res = root->data; 


    int lres = findMin(root->left); 


    int rres = findMin(root->right); 


    if (lres < res) 


        res = lres; 


    if (rres < res) 


        res = rres; 


    return res; 


} 


  


// Function to returns maximum value  


// in a given Binary Tree 


int findMax(struct Node* root) 


{ 


    // Base case 


    if (root == NULL) 


        return INT_MIN; 


  


    // Return maximum of 3 values: 


    // 1) Root's data 2) Max in Left Subtree 


    // 3) Max in right subtree 


    int res = root->data; 


    int lres = findMax(root->left); 


    int rres = findMax(root->right); 


      


    if (lres > res) 


        res = lres; 


    if (rres > res) 


        res = rres; 


    return res; 


} 


  


// Function to find sum of max and min 


// elements in the Binary Tree 


int findSum(int max , int min) 


{ 


    return max + min; 


} 


  


// Function to find product of max and min 


// elements in the Binary Tree 


int findProduct(int max, int min) 


{ 


    return max*min; 


} 


  


// Driver Code 


int main(void) 


{    


    // Create Binary Tree 


    struct Node* NewRoot = NULL; 


    struct Node* root = newNode(2); 


    root->left = newNode(7); 


    root->right = newNode(5); 


    root->left->right = newNode(6); 


    root->left->right->left = newNode(1); 


    root->left->right->right = newNode(11); 


    root->right->right = newNode(9); 


    root->right->right->left = newNode(4); 


      


    int max = findMax(root); 


    int min = findMin(root); 


      


    printf("Sum of Maximum and Minimum element is %d", 


                                           findSum(max,min)); 


    printf("\nProduct of Maximum and Minimum element is %d",  


                                        findProduct(max,min)); 


                                          


    return 0; 


} 



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python program to find sum and product of  


# maximum and minimum in a Binary Tree 


  


_MIN=-2147483648


_MAX=2147483648


  


# Helper function that allocates a new  


# node with the given data and None left  


# and right poers.                                      


class newNode:  


  


    # Constructor to create a new node  


    def __init__(self, data):  


        self.data = data  


        self.left = None


        self.right = None


  


# Function to return minimum value 


# in a given Binary Tree 


def findMin(root): 


      


    # Base case 


    if (root == None): 


        return _MAX 


  


    # Return minimum of 3 values: 


    # 1) Root's data 2) Max in Left Subtree 


    # 3) Max in right subtree 


    res = root.data 


    lres = findMin(root.left) 


    rres = findMin(root.right) 


    if (lres < res): 


        res = lres 


    if (rres < res): 


        res = rres 


    return res 


      


# Function to returns maximum value  


# in a given Binary Tree 


def findMax( root): 


      


    # Base case 


    if (root == None): 


        return _MIN 


  


    """ Return maximum of 3 values: 


    1) Root's data 2) Max in Left Subtree 


    3) Max in right subtree"""


    res = root.data 


    lres = findMax(root.left) 


    rres = findMax(root.right) 


      


    if (lres > res): 


        res = lres 


    if (rres > res): 


        res = rres 


    return res 


  


# Function to find sum of max and min 


# elements in the Binary Tree 


def findSum( max , min): 


  


    return max + min


  


# Function to find product of max and min 


# elements in the Binary Tree 


def findProduct( max, min): 


  


    return max*min


  


# Driver Code  


if __name__ == '__main__': 


    """ Create binary Tree """


    root = newNode(2)  


    root.left = newNode(7)  


    root.right = newNode(5)  


    root.left.right = newNode(6) 


    root.left.right.left = newNode(1) 


    root.left.right.right = newNode(11) 


    root.right.right = newNode(9) 


    root.right.right.left = newNode(4) 


    max = findMax(root); 


    min = findMin(root); 


      


    print("Sum of Maximum and " +


            "Minimum element is ", 


                findSum(max,min)) 


                  


    print("Product of Maximum and" +


            "Minimum element is", 


            findProduct(max,min)) 


      


  


# This code is contributed 


# Shubham Singh(SHUBHAMSINGH10) 



















                        chevron_right







                        filter_none











Output:


Sum of Maximum and Minimum element is 12
Product of Maximum and Minimum element is 11






          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
VishalBachchas
Check out this Author's contributed articles.
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.