Count Good Nodes in Binary Tree - Practice Coding Problems

Count Good Nodes in Binary Tree - Problem

Imagine you're exploring a binary tree where each node represents a checkpoint on your journey from the root to various destinations. A node is considered "good" if, throughout your entire path from the root to that node, you never encountered a value greater than the current node's value.

Your mission: Count how many "good" nodes exist in the entire binary tree.

What makes a node "good"?

Start from the root and trace the path to the target node
If no node along this path has a value greater than the target node's value, then it's good!
Note: A node can equal values on the path and still be considered good

Input: The root of a binary tree
Output: An integer representing the count of good nodes

Example: In a tree with root value 3, if we reach a node with value 4 and the path was [3 → 4], then node 4 is good because 3 ≤ 4.

Input & Output

example_1.py — Standard Binary Tree

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

› Output: 4

💡 Note: Root node (3) is always good. Path to left child (1): [3,1], 3 > 1 so not good. Path to right child (4): [3,4], 3 ≤ 4 so it's good. Path to left grandchild (3): [3,1,3], max so far is 3, and 3 ≥ 3 so it's good. Path to (1): [3,4,1], max is 4, 1 < 4 so not good. Path to (5): [3,4,5], max is 4, 5 ≥ 4 so it's good.

example_2.py — Single Node Tree

$ Input: root = [1]

› Output: 1

💡 Note: Root node is always considered good since there are no ancestors with greater values.

example_3.py — Decreasing Values

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

› Output: 5

💡 Note: All nodes are good because we never encounter a value greater than any node along its path from root. The path values are always decreasing or equal.

Visualization

Tap to expand

Understanding the Visualization

Start at Base Camp

Begin at root (elevation 3) - it's always good since no previous elevations

Track Peak Elevation

As you hike, remember the highest elevation seen so far (max = 3)

Check Each Checkpoint

At each new checkpoint, compare its elevation with your recorded peak

Count Good Checkpoints

If current elevation ≥ peak elevation, it's a good checkpoint

Key Takeaway

🎯 Key Insight: Instead of retracing every path, carry the 'peak elevation' with you as you hike through the tree once!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n nodes in the tree

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(log n) for balanced tree, O(n) for skewed tree

✓ Linear Space

Constraints

The number of nodes in the binary tree is in the range [1, 10⁵]
Each node's value is between -10⁴ and 10⁴
Tree nodes can have duplicate values
A node is good if its value is greater than or equal to all ancestor values

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal solution uses a single DFS traversal while tracking the maximum value encountered along the current path. For each node, we check if its value is greater than or equal to this maximum - if so, it's a good node. This approach achieves O(n) time complexity with O(h) space complexity where h is the tree height.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Path Retracing)	O(n²)	O(h)	For each node, traverse from root to that node to check if it's good
One-Pass DFS with Max Tracking (Optimal)	O(n)	O(h)	Track maximum value along path during single DFS traversal

Brute Force (Path Retracing) — Algorithm Steps

Traverse the tree to visit each node
For each node found, start a new traversal from root
Follow the path from root to the current node
Check if any ancestor has a value greater than current node
If no greater ancestor found, increment good node counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect All Nodes

First, traverse the tree to collect all node references

Check Each Node

For each node, start a fresh traversal from root

Trace Path

Find the path from root to current node

Validate Path

Check if any ancestor value exceeds current node value

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

void getAllNodes(struct TreeNode* node, struct TreeNode** nodes, int* count) {
    if (!node) return;
    nodes[(*count)++] = node;
    getAllNodes(node->left, nodes, count);
    getAllNodes(node->right, nodes, count);
}

bool findPath(struct TreeNode* node, struct TreeNode* target, struct TreeNode** path, int* pathLen) {
    if (!node) return false;
    
    path[(*pathLen)++] = node;
    if (node == target) return true;
    
    if (findPath(node->left, target, path, pathLen) || findPath(node->right, target, path, pathLen)) {
        return true;
    }
    
    (*pathLen)--;
    return false;
}

bool isGoodNode(struct TreeNode* root, struct TreeNode* target) {
    struct TreeNode* path[1000];
    int pathLen = 0;
    findPath(root, target, path, &pathLen);
    
    for (int i = 0; i < pathLen; i++) {
        if (path[i]->val > target->val) {
            return false;
        }
    }
    return true;
}

int goodNodes(struct TreeNode* root) {
    if (!root) return 0;
    
    struct TreeNode* allNodes[1000];
    int nodeCount = 0;
    getAllNodes(root, allNodes, &nodeCount);
    
    int count = 0;
    for (int i = 0; i < nodeCount; i++) {
        if (isGoodNode(root, allNodes[i])) {
            count++;
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially traverse O(n) ancestors to check the path

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, no additional data structures

✓ Linear Space

Constraints

The number of nodes in the binary tree is in the range [1, 10⁵]
Each node's value is between -10⁴ and 10⁴
Tree nodes can have duplicate values
A node is good if its value is greater than or equal to all ancestor values

89.4K Views

High Frequency

~18 min Avg. Time

2.9K 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Path Retracing) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler