Approach using Level Order Traversal

Approach :- Using Postorder Traversal of Tree

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

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

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

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.

Tags:

#tree-level-order #tree-traversal #DSA #Mathematical #Tree #Mathematical #Tree