Count Good Nodes in Binary Tree

Count Good Nodes in Binary Tree - Problem

Given a binary tree root, a node X in the tree is named good if in the path from root to X there are no nodes with a value greater than X.

Return the number of good nodes in the binary tree.

Input & Output

Example 1 — Standard Binary Tree

$ Input: root = [3,1,4,3,null,1,5]

› Output: 4

💡 Note: Good nodes are: 3 (root, no ancestors), 4 (path: 3→4, max=3, 4≥3), left leaf 3 (path: 3→1→3, max=3, 3≥3), and 5 (path: 3→4→5, max=4, 5≥4). Total = 4 good nodes.

Example 2 — All Values Same

$ Input: root = [3,3,null,4,2]

› Output: 3

💡 Note: Good nodes are: 3 (root), left 3 (path: 3→3, max=3, 3≥3), and 4 (path: 3→3→4, max=3, 4≥3). Node 2 is not good since path 3→3→2 has max=3 and 2<3.

Example 3 — Single Node

$ Input: root = [1]

› Output: 1

💡 Note: Only the root node exists. Root is always good since it has no ancestors to compare against.

Constraints

The number of nodes in the binary tree is in the range [1, 10⁵].
Each node's value is between [-10⁴, 10⁴].

Visualization

Tap to expand

Asked in

a Amazon 45 M Microsoft 32 G Google 28 f Facebook 25

The key insight is to track the maximum value from root to current node during DFS traversal. A node is good if its value is greater than or equal to this path maximum. Best approach is DFS with path maximum tracking. Time: O(n), Space: O(h).

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Brute Force - Check Each Path

⏱️ Time: O(n²) Space: O(h)

Visit every node and for each node, traverse from root to that node checking if any ancestor has a greater value. This requires multiple traversals.

DFS with Path Maximum

⏱️ Time: O(n) Space: O(h)

Perform depth-first search while maintaining the maximum value seen from root to current node. A node is good if its value is greater than or equal to this path maximum.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int countGoodNodes(struct TreeNode* root, int maxSoFar) {
    if (root == NULL) return 0;
    
    int isGood = (root->val >= maxSoFar) ? 1 : 0;
    int newMax = (root->val > maxSoFar) ? root->val : maxSoFar;
    
    return isGood + countGoodNodes(root->left, newMax) + countGoodNodes(root->right, newMax);
}

struct TreeNode* parseTree(char* str) {
    int len = strlen(str);
    if (len <= 2) return NULL; // "[]" case
    
    // Remove brackets
    str[len-1] = '\0';
    str++;
    
    if (strlen(str) == 0) return NULL;
    
    // Parse nodes into array
    static char* nodes[10000];
    int nodeCount = 0;
    
    char* token = strtok(str, ",");
    while (token != NULL) {
        nodes[nodeCount++] = token;
        token = strtok(NULL, ",");
    }
    
    if (nodeCount == 0) return NULL;
    
    // Create root
    struct TreeNode* root = createNode(atoi(nodes[0]));
    static struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    int i = 1;
    while (front < rear && i < nodeCount) {
        struct TreeNode* current = queue[front++];
        
        // Left child
        if (i < nodeCount && strcmp(nodes[i], "null") != 0) {
            current->left = createNode(atoi(nodes[i]));
            queue[rear++] = current->left;
        }
        i++;
        
        // Right child
        if (i < nodeCount && strcmp(nodes[i], "null") != 0) {
            current->right = createNode(atoi(nodes[i]));
            queue[rear++] = current->right;
        }
        i++;
    }
    
    return root;
}

int main() {
    static char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = '\0';
    
    struct TreeNode* root = parseTree(input);
    
    int result = countGoodNodes(root, INT_MIN);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

125.0K Views

Medium Frequency

~15 min Avg. Time

3.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen