Flip Equivalent Binary Trees - Practice Coding Problems

Flip Equivalent Binary Trees - Problem

Imagine you have two binary trees that look different, but could potentially be made identical by flipping some nodes. In a flip operation, you can choose any node and swap its left and right child subtrees.

Given the roots of two binary trees root1 and root2, determine if they are flip equivalent - meaning one can be transformed into the other through a series of flip operations.

Key Insight: Two trees are flip equivalent if at each corresponding node, the children match either in the same order OR in flipped order.

Goal: Return true if the trees are flip equivalent, false otherwise.

Input & Output

example_1.py — Basic Flip Equivalence

$ Input: root1 = [1,2,3,4,5,6,null,null,null,7,8], root2 = [1,3,2,null,6,4,5,null,null,null,null,8,7]

› Output: true

💡 Note: Tree1 can be made identical to Tree2 by flipping the children of node 1. After flipping, both trees have the same structure and values.

example_2.py — Non-Equivalent Trees

$ Input: root1 = [1,2,3], root2 = [1,2,4]

› Output: false

💡 Note: The trees cannot be made equivalent because they have different values (3 vs 4). No amount of flipping can change node values.

example_3.py — Empty Trees

$ Input: root1 = [], root2 = []

› Output: true

💡 Note: Two empty trees are always flip equivalent. This is our base case that returns true immediately.

Constraints

The number of nodes in each tree is in the range [0, 100]
Each tree will have unique node values in the range [0, 99]
Node values are integers

Visualization

Tap to expand

Understanding the Visualization

Enter Both Mazes

Start at the entrance of both mirror mazes simultaneously

Check Junction Values

At each junction, verify the room numbers match

Try Normal Path

Check if left-left and right-right paths work

Try Flipped Path

If normal doesn't work, try left-right and right-left

Declare Equivalence

If either orientation works for all paths, mazes are equivalent

Key Takeaway

🎯 Key Insight: Instead of physically flipping mirrors, we can mentally check both orientations at each junction. If either the normal path or the flipped path works throughout the entire maze, the mazes are equivalent!

Asked in

G Google 42 f Facebook 28 a Amazon 21 ⊞ Microsoft 15

The optimal solution uses recursive DFS to compare trees by checking both normal and flipped orientations at each node. Key insight: at each node, we only need to verify if children match either as-is OR when flipped. This elegant approach runs in O(n) time with O(h) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Smart Recursive Comparison (Optimal)	O(n)	O(h)	Compare trees recursively, checking both normal and flipped orientations at each node

Smart Recursive Comparison (Optimal) — Algorithm Steps

Check if both nodes are null (base case - return true)
Check if one is null or values differ (return false)
Recursively check normal orientation: left-left, right-right
Recursively check flipped orientation: left-right, right-left
Return true if either orientation works

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Root Values

Check if root values match, return false if different

Try Normal Orientation

Recursively check left-with-left and right-with-right

Try Flipped Orientation

Recursively check left-with-right and right-with-left

Return Result

Return true if either orientation works

Code -

solution.c — C

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

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

bool flipEquiv(struct TreeNode* root1, struct TreeNode* root2) {
    // Base cases
    if (!root1 && !root2) return true;
    if (!root1 || !root2) return false;
    if (root1->val != root2->val) return false;
    
    // Check two possibilities:
    // 1. Normal orientation: left matches left, right matches right
    bool normal = flipEquiv(root1->left, root2->left) && 
                  flipEquiv(root1->right, root2->right);
    
    // 2. Flipped orientation: left matches right, right matches left
    bool flipped = flipEquiv(root1->left, root2->right) && 
                   flipEquiv(root1->right, root2->left);
    
    return normal || flipped;
}

int main() {
    printf("%d\n", flipEquiv(NULL, NULL));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node at most once, where n is the total number of nodes in both trees

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals height h of the tree

✓ Linear Space

98.2K Views

Medium Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Smart Recursive Comparison (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler