Sum of Nodes with Even-Valued Grandparent

class Solution {
public:
    int getNodeValue(TreeNode* node) {
        return node ? node->val : 0;
    }
        
    int sumOfEvenGrandparent(TreeNode* root) {
        if (!root) {
            return 0;
        }
            
        queue<TreeNode*> nodeQueue;
        nodeQueue.push(root);
            
        int totalSum = 0;
        while (!nodeQueue.empty()) {
            TreeNode* currentNode = nodeQueue.front();
            nodeQueue.pop();
                
            if (currentNode->val % 2 == 0) {
                if (currentNode->left) {
                    totalSum += getNodeValue(currentNode->left->left) + getNodeValue(currentNode->left->right);
                }
                if (currentNode->right) {
                    totalSum += getNodeValue(currentNode->right->left) + getNodeValue(currentNode->right->right);
                }
            }
                
            if (currentNode->left) 
                nodeQueue.push(currentNode->left);
            if (currentNode->right)
                nodeQueue.push(currentNode->right);
        }
            
        return totalSum;
    }
};

The provided C++ code defines a solution to sum the values of nodes in a binary tree that have even-valued grandparent nodes. The implementation uses a breadth-first search approach to traverse the tree and conditional logic to sum the appropriate node values.

• getNodeValue(TreeNode* node): This helper function returns the value of the given node if it is not null; otherwise, it returns 0. This ensures safe access to node values without encountering null pointer errors.

• sumOfEvenGrandparent(TreeNode* root): This is the primary function that computes the sum. It starts by checking if the root of the tree is null. If it is, it returns 0, indicating no nodes to process. If the root is valid, the function initializes a queue for a breadth-first search. Nodes are dequeued one by one, and if a node’s value is even, the function checks its grandchildren (if any) using the helper function getNodeValue. The value of valid grandchildren nodes is added to the total sum.

  The traversal covers all levels of the tree since after checking a node, its children (if not null) are enqueued for subsequent processing. This process repeats until all nodes are processed, and the accumulated sum of valid nodes is returned.

This method leverages a queue to manage nodes as they are processed layer by layer, ensuring that all nodes with even-valued grandparents contribute to the total sum effectively. The solution is efficient in handling trees of varying sizes and structures, providing accurate results based on the given criteria.

class Solution {
    int getNodeValue(TreeNode node) {
        return node == null ? 0 : node.val;
    }
        
    public int sumEvenGrandparent(TreeNode root) {
        if (root == null) {
            return 0;
        }
            
        Queue<TreeNode> nodesQueue = new LinkedList<>();
        nodesQueue.add(root);
            
        int totalSum = 0;
        while (!nodesQueue.isEmpty()) {
            TreeNode currentNode = nodesQueue.poll();
                
            if (currentNode.val % 2 == 0) {
                if (currentNode.left != null) {
                    totalSum += getNodeValue(currentNode.left.left) + getNodeValue(currentNode.left.right);
                }
                if (currentNode.right != null) {
                    totalSum += getNodeValue(currentNode.right.left) + getNodeValue(currentNode.right.right);
                }
            }
                
            if (currentNode.left != null) 
                nodesQueue.add(currentNode.left);
            if (currentNode.right != null)
                nodesQueue.add(currentNode.right);
        }
            
        return totalSum;
    }
}

The provided Java code defines a method to calculate the sum of values of all nodes in a binary tree that have an even-valued grandparent node. It effectively utilizes a breadth-first search approach using a queue to navigate through the tree.

The key method sumEvenGrandparent(TreeNode root) initializes a queue to hold the tree nodes, integrating a level-by-level traversal. On encountering a node with an even value, the code checks for the presence of grandchildren. For any valid grandchildren nodes, their values are summed up using the helper method getNodeValue(TreeNode node), which safeguards against null nodes by returning 0.

This approach guarantees that all nodes are checked for the condition of having an even-valued grandparent, and any valid grandchildren values are accumulated into totalSum, which gets returned at the end as the solution.

Ensure proper definition and handling of the TreeNode class in your setup as it is assumed by this solution to be pre-defined with properties val, left, and right.

This approach is commendable for its simplicity and effective usage of tree traversal and condition checking techniques to solve the problem efficiently.