Symmetric Tree

Symmetric Tree - Problem

Mirror Tree Checker: Imagine looking at a binary tree and asking, "Is this tree a perfect reflection of itself?"

You're given the root of a binary tree and need to determine if it's symmetric around its center - meaning the left subtree is a mirror reflection of the right subtree.

A symmetric tree has the property that if you draw a vertical line through the root, the left side is exactly the same as the right side, but flipped horizontally. This means corresponding nodes at the same level should have equal values, and their children should be mirror images of each other.

Think of it like holding up a tree structure to a mirror - does the reflection match the original perfectly?

Input & Output

example_1.py — Perfect Symmetric Tree

$ Input: [1,2,2,3,4,4,3]

› Output: true

💡 Note: The tree is perfectly symmetric. The left subtree [2,3,4] mirrors the right subtree [2,4,3]. Each node on the left has a corresponding node with the same value at the mirrored position on the right.

example_2.py — Asymmetric Tree

$ Input: [1,2,2,null,3,null,3]

› Output: false

💡 Note: The tree is not symmetric. The left subtree has a right child with value 3, while the corresponding mirror position (left child of right subtree) is null. The structure doesn't match.

example_3.py — Single Node Tree

$ Input: [1]

› Output: true

💡 Note: A single node tree is always symmetric as there are no children to compare. The tree trivially satisfies the mirror property.

Constraints

The number of nodes in the tree is in the range [1, 1000]
-100 ≤ Node.val ≤ 100
Tree structure can vary - not necessarily complete or balanced

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 Apple 28

The optimal solution uses recursive comparison with two pointers traversing mirror positions simultaneously. We compare left.left with right.right and left.right with right.left to verify symmetry in O(n) time and O(h) space.

Common Approaches

✓ Brute Force (Serialize and Compare)

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

Serialize the left subtree in left-root-right order and the right subtree in right-root-left order, then compare the resulting strings. This approach is inefficient as it processes the entire tree structure twice and uses extra space for string storage.

Recursive Comparison (Optimal)

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

The optimal approach uses recursive comparison where we simultaneously traverse the left subtree in left-to-right order and the right subtree in right-to-left order. At each step, we check if the current nodes have equal values and their children are positioned as mirror images.

Brute Force (Serialize and Compare) — Algorithm Steps

Serialize left subtree using inorder traversal (left-root-right)
Serialize right subtree using reverse inorder traversal (right-root-left)
Compare the two serialized strings for equality
Handle null nodes by adding special markers in serialization

Visualization

Tap to expand

Step-by-Step Walkthrough

Serialize Left Subtree

Traverse left subtree in left-root-right order

Serialize Right Subtree

Traverse right subtree in right-root-left order

Compare Strings

Compare the two serialized representations

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.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;
}

void serializeLeft(struct TreeNode* node, char* result, int* pos) {
    if (!node) {
        strcat(result, "#,");
        return;
    }
    
    char temp[20];
    sprintf(temp, "%d,", node->val);
    strcat(result, temp);
    
    serializeLeft(node->left, result, pos);
    serializeLeft(node->right, result, pos);
}

void serializeRight(struct TreeNode* node, char* result, int* pos) {
    if (!node) {
        strcat(result, "#,");
        return;
    }
    
    char temp[20];
    sprintf(temp, "%d,", node->val);
    strcat(result, temp);
    
    serializeRight(node->right, result, pos);
    serializeRight(node->left, result, pos);
}

bool isSymmetric(struct TreeNode* root) {
    if (!root) return true;
    
    char leftSer[10000] = "";
    char rightSer[10000] = "";
    int pos = 0;
    
    serializeLeft(root->left, leftSer, &pos);
    pos = 0;
    serializeRight(root->right, rightSer, &pos);
    
    return strcmp(leftSer, rightSer) == 0;
}

struct TreeNode* buildTree(int* values, int size) {
    if (size == 0) return NULL;
    
    struct TreeNode* root = createNode(values[0]);
    struct TreeNode** queue = (struct TreeNode**)malloc(size * sizeof(struct TreeNode*));
    int front = 0, rear = 0;
    
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && values[i] != -1) {
            node->left = createNode(values[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && values[i] != -1) {
            node->right = createNode(values[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    free(queue);
    return root;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    int values[1000];
    int size = 0;
    char input[5000];
    
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing - assume format [1,2,3,null,4]
    char* token = strtok(input, "[],\n ");
    while (token != NULL && size < 1000) {
        if (strcmp(token, "null") == 0) {
            values[size++] = -1; // Use -1 to represent null
        } else {
            values[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n ");
    }
    
    struct TreeNode* root = buildTree(values, size);
    printf("%s\n", isSymmetric(root) ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must traverse all n nodes to create serializations, plus string comparison

✓ Linear Growth

Space Complexity

O(n)

Stores two serialized strings, each potentially containing all node values

⚡ Linearithmic Space

82.4K Views

High Frequency

~15 min Avg. Time

1.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

Brute Force (Serialize and Compare) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler