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

10 Dec, 2021
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   12Output: 3Explanation: 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    8Output: 3Explanation: For the above tree, the maximum product for the siblings is formed for nodes 6 and 9 which are the children of node 5.
Approach: 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 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++
Java
Python3
C#
Javascript
// C++ code to find the Parent Node// of maximum product Siblings// in given Binary Tree #include <bits/stdc++.h>using namespace std; // Structure for Nodestruct Node {    int data;    Node *left, *right;}; // Function to get a new nodeNode* 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 productint 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 Codeint 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 code to find the Parent Node// of maximum product Siblings// in given Binary Treeimport 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.
# Python Program to implement# the above approach # Structure of a node of binary treeclass Node:    def __init__(self, data):        self.data = data        self.left = None        self.right = None # Function to get a new nodedef getNode(data):     # Allocate space    newNode = Node(data)    return newNode # Function to get the parent# of siblings with maximum productdef 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# code to find the Parent Node// of maximum product Siblings// in given Binary Treeusing 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
<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>
  
3
 
Time Complexity: O(V) where V is the number of nodes in the tree.Auxiliary Space: O(V). 
 
lokeshpotta20
gfgking
shikhasingrajput
tree-level-order
tree-traversal
Mathematical
Tree
Mathematical
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Algorithm to solve Rubik's Cube
Program to print prime numbers from 1 to N.
Program to multiply two matrices
Fizz Buzz Implementation
Modular multiplicative inverse
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
AVL Tree | Set 1 (Insertion)
Inorder Tree Traversal without Recursion