Check If Two Expression Trees are Equivalent

Check If Two Expression Trees are Equivalent - Problem

A binary expression tree is a specialized binary tree that represents arithmetic expressions. Think of it as a mathematical formula broken down into a tree structure where:

Leaf nodes contain variables (like 'a', 'b', 'x')
Internal nodes contain operators (in this problem, only '+' for addition)

You are given the roots of two binary expression trees, root1 and root2. Your task is to determine if these trees are equivalent - meaning they would evaluate to the same result regardless of what values the variables are assigned.

Example: The expressions a + b and b + a are equivalent due to the commutative property of addition, even though their tree structures might look different.

Return true if the two expression trees are equivalent, false otherwise.

Input & Output

example_1.py — Basic Equivalence

$ Input: root1 = ['+', 'a', 'b'], root2 = ['+', 'b', 'a']

› Output: true

💡 Note: Both trees represent the expression a+b, which is equivalent to b+a due to the commutative property of addition. Tree 1: a+b, Tree 2: b+a → Same variables with same frequencies.

example_2.py — Non-Equivalent Trees

$ Input: root1 = ['+', 'a', 'b'], root2 = ['+', 'a', 'c']

› Output: false

💡 Note: Tree 1 represents a+b while Tree 2 represents a+c. These are different expressions with different variables (b vs c), so they are not equivalent.

example_3.py — Complex Nested Structure

$ Input: root1 = ['+', ['+', 'a', 'b'], 'c'], root2 = ['+', 'a', ['+', 'b', 'c']]

› Output: true

💡 Note: Tree 1: (a+b)+c, Tree 2: a+(b+c). Both expressions equal a+b+c due to associativity of addition. Variable frequencies are the same: a=1, b=1, c=1 in both trees.

Visualization

Tap to expand

Understanding the Visualization

Initialize Counter

Create a frequency map to track variable occurrences

Process First Tree

Traverse tree 1, adding +1 for each variable leaf

Process Second Tree

Traverse tree 2, adding -1 for each variable leaf

Check Balance

If all counters are zero, trees have identical variable frequencies

Key Takeaway

🎯 Key Insight: Since addition is commutative and associative, two expression trees are equivalent if and only if they contain the same variables with the same frequencies - tree structure doesn't matter!

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Where n and m are the sizes of the two trees. We visit each node exactly once.

✓ Linear Growth

Space Complexity

O(h + v)

Where h is the maximum height of trees (for recursion) and v is the number of unique variables

✓ Linear Space

Constraints

The number of nodes in both trees are equal and is in the range [1, 4999].
Node.val.length == 1
Node.val is either '+' or a lowercase English letter.
It's guaranteed that the tree given is a valid binary expression tree.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 25

The optimal solution uses a variable frequency counter approach. Since addition is commutative and associative, two expression trees are equivalent if and only if they contain the same variables with the same frequencies. We traverse the first tree adding +1 for each variable, traverse the second tree adding -1 for each variable, and check if all final counts are zero. This elegant solution runs in O(n+m) time and O(v) space where v is the number of unique variables.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Expression Evaluation)	O(2^v * n)	O(v)	Generate all variable assignments and compare evaluations
Variable Frequency Counter (Optimal)	O(n + m)	O(h + v)	Count variable frequencies in both trees and compare

Brute Force (Expression Evaluation) — Algorithm Steps

Collect all unique variables from both trees
Generate multiple random variable assignments
For each assignment, evaluate both trees
If any evaluation produces different results, return false
If all evaluations match, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Variables

Traverse both trees to find all unique variables

Generate Assignment

Create random values for each variable

Evaluate Trees

Calculate the result of both expression trees

Compare Results

If any assignment gives different results, trees are not equivalent

Code -

solution.c — C

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

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

// Simple hash table for variables
#define MAX_VARS 100
struct VarMap {
    char vars[MAX_VARS][10];
    int values[MAX_VARS];
    int size;
};

void collectVars(struct TreeNode* root, struct VarMap* varsMap) {
    if (!root) return;
    if (!root->left && !root->right) {
        // Check if variable already exists
        for (int i = 0; i < varsMap->size; i++) {
            if (strcmp(varsMap->vars[i], root->val) == 0) {
                return;
            }
        }
        // Add new variable
        if (varsMap->size < MAX_VARS) {
            strcpy(varsMap->vars[varsMap->size], root->val);
            varsMap->size++;
        }
    }
    collectVars(root->left, varsMap);
    collectVars(root->right, varsMap);
}

int evaluate(struct TreeNode* root, struct VarMap* assignment) {
    if (!root) return 0;
    if (!root->left && !root->right) {
        for (int i = 0; i < assignment->size; i++) {
            if (strcmp(assignment->vars[i], root->val) == 0) {
                return assignment->values[i];
            }
        }
        return 0;
    }
    int leftVal = evaluate(root->left, assignment);
    int rightVal = evaluate(root->right, assignment);
    return leftVal + rightVal;
}

bool checkEquivalence(struct TreeNode* root1, struct TreeNode* root2) {
    struct VarMap allVars = {.size = 0};
    collectVars(root1, &allVars);
    collectVars(root2, &allVars);
    
    // Test multiple random assignments
    srand(time(NULL));
    
    for (int i = 0; i < 100; i++) {
        struct VarMap assignment = allVars;
        for (int j = 0; j < assignment.size; j++) {
            assignment.values[j] = rand() % 11;
        }
        if (evaluate(root1, &assignment) != evaluate(root2, &assignment)) {
            return false;
        }
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^v * n)

Where v is number of unique variables and n is tree size. We need exponentially many evaluations.

✓ Linear Growth

Space Complexity

O(v)

Space to store variable assignments and evaluation recursion

✓ Linear Space

Constraints

The number of nodes in both trees are equal and is in the range [1, 4999].
Node.val.length == 1
Node.val is either '+' or a lowercase English letter.
It's guaranteed that the tree given is a valid binary expression tree.

26.5K Views

Medium Frequency

~15 min Avg. Time

892 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 (Expression Evaluation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler