Sponsored
Sponsored
This approach uses a depth-first search traversal to keep track of the current node's parent and grandparent values. If the grandparent's value is even, the node's value is added to the sum.
We initiate the DFS with the root, setting initial parent and grandparent values as null or zero.
Time Complexity: O(n) where n is the number of nodes. Each node is visited once.
Space Complexity: O(h) where h is the height of the tree due to the recursion stack.
1class TreeNode:
2 def __init__(self, val=0, left=None, right=None):
3 self.val = val
4 self.left = left
5 self.right = right
6
7def sumEvenGrandparent(root: TreeNode) -> int:
8 def dfs(node, parent, grandparent):
9 if not node:
10 return 0
11 total = 0
12 if grandparent and grandparent.val % 2 == 0:
13 total += node.val
14 total += dfs(node.left, node, parent)
15 total += dfs(node.right, node, parent)
16 return total
17 return dfs(root, None, None)In this code, we define a helper method dfs that takes the current node, its parent, and the grandparent node as arguments. We traverse the tree recursively, checking if the grandparent node exists and has an even value. If so, we add the current node's value to the total sum. The function returns the computed sum for all nodes valid under the given condition.
Utilizing an iterative method with breadth-first traversal (via a queue) enables level-wise examination of tree nodes. This format offers insight into parent-grandchild relations by leveraging node attributes over iteration.
Time Complexity: O(n), where n is the count of nodes due to single node examination.
Space Complexity: O(w), w being the maximum width of the tree, accounting for queue storage.
#include <queue>
using namespace std;
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
public:
int sumEvenGrandparent(TreeNode* root) {
queue<pair<TreeNode*, pair<TreeNode*, TreeNode*>>> q;
q.push({root, {nullptr, nullptr}});
int sum = 0;
while (!q.empty()) {
auto [node, parentGrandparent] = q.front();
q.pop();
TreeNode* parent = parentGrandparent.first;
TreeNode* grandparent = parentGrandparent.second;
if (!node) continue;
if (grandparent && grandparent->val % 2 == 0) {
sum += node->val;
}
q.push({node->left, {node, parent}});
q.push({node->right, {node, parent}});
}
return sum;
}
};The C++ implementation follows a similar structure utilizing a queue to systematically pursue level-order traversal. Elements in the queue maintain node, parent, and grandparent associations, enabling easy validation and sum updates.