Evaluate Boolean Binary Tree - Practice Coding Problems

Evaluate Boolean Binary Tree - Problem

You're given a full binary tree that represents a boolean expression ready to be evaluated! This tree has a special structure:

Leaf nodes contain values 0 (False) or 1 (True) - these are your boolean literals
Non-leaf nodes contain values 2 (OR operation) or 3 (AND operation) - these are your boolean operators

Your mission is to evaluate this boolean expression tree and return the final result.

How evaluation works:

🍃 Leaf nodes: Simply return their value (0 = False, 1 = True)
🌿 Non-leaf nodes: Evaluate both children, then apply the boolean operation

Think of it like parsing a mathematical expression, but with boolean logic instead of arithmetic!

Note: A full binary tree means every node has either 0 children (leaf) or exactly 2 children (internal node).

Input & Output

example_1.py — Simple OR Operation

$ Input: root = [2,1,3,null,null,0,1]

› Output: true

💡 Note: The tree represents (True OR (False AND True)). First evaluate (False AND True) = False, then (True OR False) = True.

example_2.py — Simple AND Operation

$ Input: root = [3,1,0]

› Output: false

💡 Note: The tree represents (True AND False) = False. Both children are leaves, so we directly apply the AND operation.

example_3.py — Single Leaf Node

$ Input: root = [1]

› Output: true

💡 Note: Single leaf node with value 1, which represents True.

Visualization

Tap to expand

Understanding the Visualization

Identify Node Type

Check if current node is a leaf (0 or 1) or operator (2 or 3)

Base Case

If leaf, return corresponding boolean value

Recursive Case

Evaluate left and right subtrees recursively

Apply Operation

Use AND (3) or OR (2) on the children's results

Bubble Up

Return result to parent node in the recursion

Key Takeaway

🎯 Key Insight: Tree recursion naturally matches the structure of boolean expressions - evaluate children first, then apply the parent's operation

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once where n is number of nodes

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 1000]
Node values are 0, 1, 2, or 3 only
0 and 1 represent False and True respectively
2 and 3 represent OR and AND operations respectively
The tree is a full binary tree

Asked in

f Meta 25 a Amazon 18 G Google 15 ⊞ Microsoft 12

The optimal approach uses recursive depth-first search to evaluate the boolean binary tree. For each node, we check if it's a leaf (return its boolean value) or recursively evaluate both children and apply the boolean operation. This gives us O(n) time complexity with O(h) space for the recursion stack.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive DFS (Optimal for Trees)	O(n)	O(h)	Recursively evaluate each subtree from bottom-up

Recursive DFS (Optimal for Trees) — Algorithm Steps

Check if current node is a leaf (no children)
If leaf, return the boolean value (0 or 1)
If not leaf, recursively evaluate left and right children
Apply the boolean operation (AND for 3, OR for 2) to children's results
Return the computed boolean result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin evaluation at root node, check if it's a leaf

Recurse Left

Recursively evaluate left subtree first

Recurse Right

Recursively evaluate right subtree

Apply Operation

Use node's operation (AND/OR) on children results

Return Result

Return computed boolean value up the recursion

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;
};

bool evaluateTree(struct TreeNode* root) {
    // Base case: leaf node
    if (root->left == NULL && root->right == NULL) {
        return root->val == 1;
    }
    
    // Recursive case: evaluate children
    bool leftResult = evaluateTree(root->left);
    bool rightResult = evaluateTree(root->right);
    
    // Apply operation
    if (root->val == 2) { // OR operation
        return leftResult || rightResult;
    } else { // root->val == 3, AND operation
        return leftResult && rightResult;
    }
}

int main() {
    // Parse input and test
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once where n is number of nodes

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 1000]
Node values are 0, 1, 2, or 3 only
0 and 1 represent False and True respectively
2 and 3 represent OR and AND operations respectively
The tree is a full binary tree

42.0K Views

Medium Frequency

~12 min Avg. Time

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

Recursive DFS (Optimal for Trees) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler