Open In App
Related Articles

Find the parent node of maximum product Siblings in given Binary Tree

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given a binary tree, the task is to find the node whose children have maximum Sibling product in the given Binary Tree. If there are multiple such nodes, return the node which has the maximum value.

Examples:

Input: Tree:
              4
           /   \
         5     2
      /  \
    3    1
  /  \
6   12
Output: 3
Explanation: For the above tree, the maximum product for the siblings is formed for nodes 6 and 12 which are the children of node 3.

Input: Tree:
                1
             /    \
          3       5
       /  \     /  \
     6    9  4    8
Output: 3
Explanation: For the above tree, the maximum product for the siblings is formed for nodes 6 and 9 which are the children of node 3.

Approach using Level Order Traversal:

To solve this problem, level order traversal of the Binary Tree can be used to find the maximum sum of siblings. Follow the following steps:

  • Start level order traversal of the tree from root of the tree.
  • For each node, check if it has both the child.
    • If yes, then find the node with maximum product of children and store this node value in a reference variable.
    • Update the node value in reference variable if any node is found with greater product of children.
  • If the current node don’t have both children, then skip that node
  • Return the node value in reference variable, as it contains the node with maximum product of children, or the parent of maximum product siblings.

Below is the implementation of the above approach:

C++

// C++ code to find the Parent Node
// of maximum product Siblings
// in given Binary Tree
 
#include <bits/stdc++.h>
using namespace std;
 
// Structure for Node
struct Node {
    int data;
    Node *left, *right;
};
 
// Function to get a new node
Node* getNode(int data)
{
    // Allocate space
    Node* newNode
      = (Node*)malloc(sizeof(Node));
 
    // Put in the data
    newNode->data = data;
    newNode->left = newNode->right = NULL;
    return newNode;
}
 
// Function to get the parent
// of siblings with maximum product
int maxproduct(Node* root)
{
    int mproduct = INT_MIN;
    int ans = 0;
 
    // Checking base case
    if (root == NULL
        || (root->left == NULL
            && root->right == NULL))
        return 0;
 
    // Declaration of queue to run
    // level order traversal
    queue<Node*> q;
    q.push(root);
 
    // Loop to implement level order traversal
    while (!q.empty()) {
        Node* temp = q.front();
        q.pop();
 
        // If both the siblings are present
        // then take their product
        if (temp->right && temp->left) {
            int curr_max
                = temp->right->data
              * temp->left->data;
            if (mproduct < curr_max) {
                mproduct = curr_max;
                ans = temp->data;
            }
            else if (mproduct == curr_max) {
 
                // if max product is equal to
                // curr_max then consider node
                // which has maximum value
                ans = max(ans, temp->data);
            }
        }
 
        // pushing childs in the queue
        if (temp->right) {
            q.push(temp->right);
        }
        if (temp->left) {
            q.push(temp->left);
        }
    }
    return ans;
}
 
// Driver Code
int main()
{
    /* Binary tree creation
              1
            /   \
           3     5
          / \   / \
         6   9 4   8
      */
    Node* root = getNode(1);
    root->left = getNode(3);
    root->right = getNode(5);
    root->left->left = getNode(6);
    root->left->right = getNode(9);
    root->right->left = getNode(4);
    root->right->right = getNode(8);
 
    cout << maxproduct(root) << endl;
    return 0;
}

                    

Java

// Java code to find the Parent Node
// of maximum product Siblings
// in given Binary Tree
import java.util.LinkedList;
import java.util.Queue;
 
class GFG {
 
    // Structure for Node
    static class Node {
        int data;
        Node left;
        Node right;
 
        public Node(int data) {
            this.data = data;
            this.left = null;
            this.right = null;
        }
    };
 
    // Function to get a new node
    public static Node getNode(int data) {
        // Allocate space
        Node newNode = new Node(data);
 
        // Put in the data
        newNode.data = data;
        newNode.left = newNode.right = null;
        return newNode;
    }
 
    // Function to get the parent
    // of siblings with maximum product
    public static int maxproduct(Node root) {
        int mproduct = Integer.MIN_VALUE;
        int ans = 0;
 
        // Checking base case
        if (root == null
                || (root.left == null
                        && root.right == null))
            return 0;
 
        // Declaration of queue to run
        // level order traversal
        Queue<Node> q = new LinkedList<Node>();
 
        q.add(root);
 
        // Loop to implement level order traversal
        while (!q.isEmpty()) {
            Node temp = q.peek();
            q.remove();
 
            // If both the siblings are present
            // then take their product
            if (temp.right != null && temp.left != null) {
                int curr_max = temp.right.data
                        * temp.left.data;
                if (mproduct < curr_max) {
                    mproduct = curr_max;
                    ans = temp.data;
                } else if (mproduct == curr_max) {
 
                    // if max product is equal to
                    // curr_max then consider node
                    // which has maximum value
                    ans = Math.max(ans, temp.data);
                }
            }
 
            // pushing childs in the queue
            if (temp.right != null) {
                q.add(temp.right);
            }
            if (temp.left != null) {
                q.add(temp.left);
            }
        }
        return ans;
    }
 
    // Driver Code
    public static void main(String args[]) {
        /*
         * Binary tree creation
         * 1
         * / \
         * 3 5
         * / \ / \
         * 6 9 4 8
         */
        Node root = getNode(1);
        root.left = getNode(3);
        root.right = getNode(5);
        root.left.left = getNode(6);
        root.left.right = getNode(9);
        root.right.left = getNode(4);
        root.right.right = getNode(8);
 
        System.out.println(maxproduct(root));
    }
}
 
// This code is contributed by gfgking.

                    

Python3

# Python Program to implement
# the above approach
 
# Structure of a node of binary tree
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
 
# Function to get a new node
def getNode(data):
 
    # Allocate space
    newNode = Node(data)
    return newNode
 
# Function to get the parent
# of siblings with maximum product
def maxproduct(root):
    mproduct = 10 ** -9
    ans = 0;
 
    # Checking base case
    if (root == None or (root.left == None and root.right == None)):
        return 0;
 
    # Declaration of queue to run
    # level order traversal
    q = [];
    q.append(root);
 
    # Loop to implement level order traversal
    while (len(q)):
        temp = q[0];
        q.pop(0);
 
        # If both the siblings are present
        # then take their product
        if (temp.right and temp.left):
            curr_max = temp.right.data * temp.left.data;
            if (mproduct < curr_max):
                mproduct = curr_max
                ans = temp.data
            elif (mproduct == curr_max):
 
                # if max product is equal to
                # curr_max then consider node
                # which has maximum value
                ans = max(ans, temp.data)
 
        # pushing childs in the queue
        if (temp.right):
            q.append(temp.right)
        if (temp.left):
            q.append(temp.left)
 
    return ans
 
# Driver Code
 
""" Binary tree creation
            1
        /   \
        3     5
        / \   / \
        6   9 4   8
"""
root = getNode(1);
root.left = getNode(3);
root.right = getNode(5);
root.left.left = getNode(6);
root.left.right = getNode(9);
root.right.left = getNode(4);
root.right.right = getNode(8);
 
print(maxproduct(root));
 
# This code is contributed by gfgking

                    

C#

// C# code to find the Parent Node
// of maximum product Siblings
// in given Binary Tree
using System;
using System.Collections.Generic;
 
public class GFG {
 
    // Structure for Node
    class Node {
        public int data;
        public Node left;
        public Node right;
 
        public Node(int data) {
            this.data = data;
            this.left = null;
            this.right = null;
        }
    };
 
    // Function to get a new node
    static Node getNode(int data) {
        // Allocate space
        Node newNode = new Node(data);
 
        // Put in the data
        newNode.data = data;
        newNode.left = newNode.right = null;
        return newNode;
    }
 
    // Function to get the parent
    // of siblings with maximum product
    static int maxproduct(Node root) {
        int mproduct = int.MinValue;
        int ans = 0;
 
        // Checking base case
        if (root == null
                || (root.left == null
                        && root.right == null))
            return 0;
 
        // Declaration of queue to run
        // level order traversal
        Queue<Node> q = new Queue<Node>();
 
        q.Enqueue(root);
 
        // Loop to implement level order traversal
        while (q.Count!=0) {
            Node temp = q.Peek();
            q.Dequeue();
 
            // If both the siblings are present
            // then take their product
            if (temp.right != null && temp.left != null) {
                int curr_max = temp.right.data
                        * temp.left.data;
                if (mproduct < curr_max) {
                    mproduct = curr_max;
                    ans = temp.data;
                } else if (mproduct == curr_max) {
 
                    // if max product is equal to
                    // curr_max then consider node
                    // which has maximum value
                    ans = Math.Max(ans, temp.data);
                }
            }
 
            // pushing childs in the queue
            if (temp.right != null) {
                q.Enqueue(temp.right);
            }
            if (temp.left != null) {
                q.Enqueue(temp.left);
            }
        }
        return ans;
    }
 
    // Driver Code
    public static void Main(String []args) {
        /*
         * Binary tree creation
         * 1
         * / \
         * 3 5
         * / \ / \
         * 6 9 4 8
         */
        Node root = getNode(1);
        root.left = getNode(3);
        root.right = getNode(5);
        root.left.left = getNode(6);
        root.left.right = getNode(9);
        root.right.left = getNode(4);
        root.right.right = getNode(8);
 
        Console.WriteLine(maxproduct(root));
    }
}
 
// This code is contributed by shikhasingrajput

                    

Javascript

<script>
 
        // JavaScript Program to implement
        // the above approach
 
        // Structure of a node of binary tree
        class Node {
            constructor(data) {
                this.data = data;
                this.left = null;
                this.right = null;
            }
        };
 
        // Function to get a new node
        function getNode(data)
        {
         
            // Allocate space
            let newNode
                = new Node(data);
            return newNode;
        }
 
        // Function to get the parent
        // of siblings with maximum product
        function maxproduct(root) {
            let mproduct = Number.MIN_VALUE;
            let ans = 0;
 
            // Checking base case
            if (root == null
                || (root.left == null
                    && root.right == null))
                return 0;
 
            // Declaration of queue to run
            // level order traversal
            let q = [];
            q.push(root);
 
            // Loop to implement level order traversal
            while (!q.length == 0) {
                let temp = q[0];
                q.shift();
 
                // If both the siblings are present
                // then take their product
                if (temp.right && temp.left) {
                    let curr_max
                        = temp.right.data
                        * temp.left.data;
                    if (mproduct < curr_max) {
                        mproduct = curr_max;
                        ans = temp.data;
                    }
                    else if (mproduct == curr_max) {
 
                        // if max product is equal to
                        // curr_max then consider node
                        // which has maximum value
                        ans = Math.max(ans, temp.data);
                    }
                }
 
                // pushing childs in the queue
                if (temp.right) {
                    q.push(temp.right);
                }
                if (temp.left) {
                    q.push(temp.left);
                }
            }
            return ans;
        }
 
        // Driver Code
 
        /* Binary tree creation
                  1
                /   \
               3     5
              / \   / \
             6   9 4   8
          */
        let root = getNode(1);
        root.left = getNode(3);
        root.right = getNode(5);
        root.left.left = getNode(6);
        root.left.right = getNode(9);
        root.right.left = getNode(4);
        root.right.right = getNode(8);
 
        document.write(maxproduct(root) + "<br>");
 
    // This code is contributed by Potta Lokesh
    </script>

                    

Output
3






Time Complexity: O(V) where V is the number of nodes in the tree.
Auxiliary Space: O(V). 

Approach :- Using Postorder Traversal of Tree

    • The idea is to traverse the tree in postorder fashion .
    • Recursively , call the left subtree.
    • Recursively , call the right subtree.
    • Get , the product of left child and right child and update the max variable and max parent variable with parent root of left and right child.
    • Here , max parent variable will be storing the parent node of the maximum product siblings.

    Below is the Implementation of this Approach :-

    C++

    #include <climits>
    #include <iostream>
     
    // Structure for Node
    struct Node {
        int data;
        Node* left;
        Node* right;
     
        Node(int data)
            : data(data)
            , left(nullptr)
            , right(nullptr)
        {
        }
    };
     
    // Function to get a new node
    Node* getNode(int data)
    {
        // Allocate space
        Node* newNode = new Node(data);
     
        // Put in the data
        newNode->data = data;
        newNode->left = newNode->right = nullptr;
        return newNode;
    }
     
    // Initialize, parentNode with -1
    int parentNode = -1;
     
    // Initialize, maxProductVal with INT_MIN
    int maxProductVal = INT_MIN;
     
    // Forward declaration of the helper function
    int helper(Node* root);
     
    // Function to get the parent of siblings with maximum
    // product
    int calculateMaxProduct(Node* root)
    {
        // calling helper function to get ParentNode
        helper(root);
     
        return parentNode;
    }
     
    int helper(Node* root)
    {
        // Base Case
        if (root == nullptr) {
            return 0;
        }
     
        // recursively, calling left part
        int left = helper(root->left);
     
        // recursively, calling right part
        int right = helper(root->right);
     
        // multiplying left and right to get product of the root
        int currProduct = left * right;
     
        // update maxProduct
        if (maxProductVal < currProduct) {
            maxProductVal = currProduct;
     
            // update the parentNode
            parentNode = root->data;
        }
     
        // return root data for every node
        return root->data;
    }
     
    // Driver Code
    int main()
    {
        /*
         * Binary tree creation
         *   1
         *  / \
         * 3   5
         * / \ / \
         * 6 9 4 8
         */
        Node* root = getNode(1);
        root->left = getNode(3);
        root->right = getNode(5);
        root->left->left = getNode(6);
        root->left->right = getNode(9);
        root->right->left = getNode(4);
        root->right->right = getNode(8);
     
        std::cout << calculateMaxProduct(root) << std::endl;
     
        // Free allocated memory
        delete root->left->left;
        delete root->left->right;
        delete root->right->left;
        delete root->right->right;
        delete root->left;
        delete root->right;
        delete root;
     
        return 0;
    }
    
                        

    Java

    // Java code to find the Parent Node
    // of maximum product Siblings
    // in given Binary Tree
    import java.util.LinkedList;
    import java.util.Queue;
     
    class GFG {
     
        // Structure for Node
        static class Node {
            int data;
            Node left;
            Node right;
     
            public Node(int data)
            {
                this.data = data;
                this.left = null;
                this.right = null;
            }
        };
     
        // Function to get a new node
        public static Node getNode(int data)
        {
            // Allocate space
            Node newNode = new Node(data);
     
            // Put in the data
            newNode.data = data;
            newNode.left = newNode.right = null;
            return newNode;
        }
     
        // Initialize , parentNode with -1
        static int parentNode = -1;
     
        // Initialize , maxProduct with INT_MIN
        static int maxProduct = Integer.MIN_VALUE;
     
        // Function to get the parent
        // of siblings with maximum product
     
        public static int maxproduct(Node root)
        {
     
            // calling helper function to get
            //  ParentNode
     
            helper(root);
     
            return parentNode;
        }
        static int helper(Node root)
        {
            // Base Case
            if (root == null) {
                return 0;
            }
     
            // recursively , calling left part
     
            int left = helper(root.left);
     
            // recursively , calling right part
     
            int right = helper(root.right);
     
            // multiplying left and right to get product
            // of the root
     
            int currProduct = left * right;
     
            // update maxProduct
     
            if (maxProduct < currProduct) {
                maxProduct = currProduct;
     
                // update the parentNode
     
                parentNode = root.data;
            }
     
            // return root data for every node
     
            return root.data;
        }
     
        // Driver Code
        public static void main(String args[])
        {
            /*
             * Binary tree creation
             * 1
             * / \
             * 3 5
             * / \ / \
             * 6 9 4 8
             */
            Node root = getNode(1);
            root.left = getNode(3);
            root.right = getNode(5);
            root.left.left = getNode(6);
            root.left.right = getNode(9);
            root.right.left = getNode(4);
            root.right.right = getNode(8);
     
            System.out.println(maxproduct(root));
        }
    }
     
    // This code is contributed by srimann7
    
                        

    Python

    import sys
     
    # Class definition for Node
     
     
    class Node:
        def __init__(self, data):
            self.data = data
            self.left = None
            self.right = None
     
    # Function to get a new node
     
     
    def get_node(data):
        # Allocate space
        new_node = Node(data)
     
        # Put in the data
        new_node.data = data
        new_node.left = new_node.right = None
        return new_node
     
     
    # Initialize parentNode with -1
    parent_node = -1
     
    # Initialize max_product_val with INT_MIN
    max_product_val = -sys.maxsize - 1
     
    # Helper function to calculate the maximum product
     
     
    def helper(root):
        global parent_node, max_product_val
     
        # Base Case
        if root is None:
            return 0
     
        # Recursively calling left part
        left = helper(root.left)
     
        # Recursively calling right part
        right = helper(root.right)
     
        # Multiplying left and right to get the product of the root
        curr_product = left * right
     
        # Update max_product_val
        if max_product_val < curr_product:
            max_product_val = curr_product
     
            # Update the parent_node
            parent_node = root.data
     
        # Return root data for every node
        return root.data
     
    # Function to calculate the parent of siblings with the maximum product
     
     
    def calculate_max_product(root):
        # Calling the helper function to get parent_node
        helper(root)
     
        return parent_node
     
     
    # Driver Code
    if __name__ == "__main__":
        """
        Binary tree creation
            1
           / \
          3   5
         / \ / \
        6  9 4  8
        """
        root = get_node(1)
        root.left = get_node(3)
        root.right = get_node(5)
        root.left.left = get_node(6)
        root.left.right = get_node(9)
        root.right.left = get_node(4)
        root.right.right = get_node(8)
     
        print(calculate_max_product(root))
     
        # Free allocated memory
        del root.left.left
        del root.left.right
        del root.right.left
        del root.right.right
        del root.left
        del root.right
        del root
    
                        

    C#

    using System;
     
    // Structure for Node
    public class Node {
        public int data;
        public Node left;
        public Node right;
     
        public Node(int data)
        {
            this.data = data;
            this.left = null;
            this.right = null;
        }
    }
     
    public class BinaryTree {
        // Initialize parentNode with -1
        private static int parentNode = -1;
     
        // Initialize maxProductVal with int.MinValue
        private static int maxProductVal = int.MinValue;
     
        // Function to get the parent of siblings with maximum
        // product
        private static int CalculateMaxProduct(Node root)
        {
            // calling helper function to get parentNode
            Helper(root);
     
            return parentNode;
        }
     
        private static int Helper(Node root)
        {
            // Base Case
            if (root == null) {
                return 0;
            }
     
            // Recursively calling the left part
            int left = Helper(root.left);
     
            // Recursively calling the right part
            int right = Helper(root.right);
     
            // Multiplying left and right to get the product of
            // the root
            int currProduct = left * right;
     
            // Update maxProduct
            if (maxProductVal < currProduct) {
                maxProductVal = currProduct;
     
                // Update the parentNode
                parentNode = root.data;
            }
     
            // Return root data for every node
            return root.data;
        }
     
        // Driver Code
        public static void Main()
        {
            /*
             * Binary tree creation
             *   1
             *  / \
             * 3   5
             * / \ / \
             * 6 9 4 8
             */
            Node root = new Node(1);
            root.left = new Node(3);
            root.right = new Node(5);
            root.left.left = new Node(6);
            root.left.right = new Node(9);
            root.right.left = new Node(4);
            root.right.right = new Node(8);
     
            Console.WriteLine(CalculateMaxProduct(root));
     
            // No need to free memory in C#, as it is managed by
            // the garbage collector
        }
    }
    
                        

    Javascript

    // Structure for Node
    class Node {
      constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
      }
    }
     
    // Function to get a new node
    function getNode(data) {
      const newNode = new Node(data);
      newNode.data = data;
      newNode.left = null;
      newNode.right = null;
      return newNode;
    }
     
    // Initialize parentNode with -1
    let parentNode = -1;
     
    // Initialize maxProductVal with Number.MIN_SAFE_INTEGER
    let maxProductVal = Number.MIN_SAFE_INTEGER;
     
    // Forward declaration of the helper function
    function helper(root) {
      // Base Case
      if (root === null) {
        return 0;
      }
     
      // Recursively calling left part
      const left = helper(root.left);
     
      // Recursively calling right part
      const right = helper(root.right);
     
      // Multiplying left and right to get product of the root
      const currProduct = left * right;
     
      // Update maxProduct
      if (maxProductVal < currProduct) {
        maxProductVal = currProduct;
     
        // Update the parentNode
        parentNode = root.data;
      }
     
      // Return root data for every node
      return root.data;
    }
     
    // Function to get the parent of siblings with maximum product
    function calculateMaxProduct(root) {
      // Calling helper function to get parentNode
      helper(root);
     
      return parentNode;
    }
     
    // Driver Code
    /*
     * Binary tree creation
     *   1
     *  / \
     * 3   5
     * / \ / \
     * 6 9 4 8
     */
    const root = getNode(1);
    root.left = getNode(3);
    root.right = getNode(5);
    root.left.left = getNode(6);
    root.left.right = getNode(9);
    root.right.left = getNode(4);
    root.right.right = getNode(8);
     
    console.log(calculateMaxProduct(root));
    
                        

    Output
    3
    
    
    
    
    
    

    Time Complexity: O(N) , where N is the number of nodes in the tree
    Auxiliary Space : O(N) , recursion stack space
     



    Last Updated : 26 Dec, 2023
    Like Article
    Save Article
    Previous
    Next
    Share your thoughts in the comments
    Similar Reads