Symmetric Tree - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Identify the Center Line

Draw a vertical line through the root node - this is our axis of symmetry

Compare Mirror Positions

For each node on the left, find its mirror position on the right and verify equal values

Check Structure

Ensure that if a node exists at position (level, offset), a corresponding node exists at (level, -offset)

Key Takeaway

🎯 Key Insight: Two synchronized traversals comparing mirror positions can verify tree symmetry efficiently in a single pass, avoiding the need for serialization or multiple tree scans.

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

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

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

Approach	Time	Space	Notes
✓ Brute Force (Serialize and Compare)	O(n)	O(n)	Convert tree to string representations and compare them
Recursive Comparison (Optimal)	O(n)	O(h)	Compare left and right subtrees recursively using mirror traversal

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

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

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Serialize and Compare) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler