Symmetric Tree (Mirror Image of itself)
Last Updated :
07 Jun, 2025
Improve
Try it on GfG Practice 
Given a binary tree, the task is to check whether it is a mirror of itself.
Example:
Input: root[] = [1, 2, 2, 3, 4, 4, 3]
Output: True
Explanation: Tree is mirror image of itself i.e. tree is symmetric.Input: root[] = [1, 2, 2, N, 3, N, 3]
Output: False
Explanation: Tree is not mirror image of itself i.e. tree is not symmetric.
Table of Content
[Approach - 1] Using Recursion - O(n) Time and O(h) Space
The idea is to recursively compare the left and right subtrees of the root. For the tree to be symmetric, the root values of the left and right subtrees must match, and their corresponding children must also be mirrors.
// C++ program to check if a given Binary
// Tree is symmetric
#include <iostream>
using namespace std;
class Node {
public:
int data;
Node *left, *right;
Node(int val) {
data = val;
left = right = nullptr;
}
};
// Recursive helper function to check if two subtrees are mirror images
bool isMirror(Node* leftSub, Node* rightSub) {
// Both are null, so they are mirror images
if (leftSub == nullptr && rightSub == nullptr)
return true;
// One of them is null, so they aren't mirror images
if (leftSub == nullptr || rightSub == nullptr ||
leftSub->data != rightSub->data) {
return false;
}
// Check if the subtrees are mirrors
return isMirror(leftSub->left, rightSub->right) &&
isMirror(leftSub->right, rightSub->left);
}
bool isSymmetric(Node* root) {
// If tree is empty, it's symmetric
if (root == nullptr)
return true;
// Check if the left and right subtrees are
// mirrors of each other
return isMirror(root->left, root->right);
}
int main() {
// Creating a sample symmetric binary tree
// 1
// / \
// 2 2
// / \ / \
// 3 4 4 3
Node* root = new Node(1);
root->left = new Node(2);
root->right = new Node(2);
root->left->left = new Node(3);
root->left->right = new Node(4);
root->right->left = new Node(4);
root->right->right = new Node(3);
if(isSymmetric(root))
cout << "true";
else
cout << "false";
return 0;
}
// Java program to check if a given
// Binary Tree is symmetric
class Node {
int data;
Node left, right;
Node(int val) {
data = val;
left = right = null;
}
}
class GfG{
// Recursive helper function to check if two subtrees are mirror images
static boolean isMirror(Node leftSub, Node rightSub) {
// Both are null, so they are mirror images
if (leftSub == null && rightSub == null)
return true;
// One of them is null, so they aren't mirror images
if (leftSub == null || rightSub == null
|| leftSub.data != rightSub.data)
return false;
// Check if the subtrees are mirrors
return isMirror(leftSub.left, rightSub.right) &&
isMirror(leftSub.right, rightSub.left);
}
static boolean isSymmetric(Node root) {
// If tree is empty, it's symmetric
if (root == null)
return true;
// Check if the left and right subtrees are mirrors of each other
return isMirror(root.left, root.right);
}
public static void main(String[] args) {
// Creating a sample symmetric binary tree
// 1
// / \
// 2 2
// / \ / \
// 3 4 4 3
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(2);
root.left.left = new Node(3);
root.left.right = new Node(4);
root.right.left = new Node(4);
root.right.right = new Node(3);
if (isSymmetric(root))
System.out.println("true");
else
System.out.println("false");
}
}
# Python program to check if a given
# Binary Tree is symmetric
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
# Recursive helper function to check if two subtrees are mirror images
def isMirror(leftSub, rightSub):
# Both are null, so they are mirror images
if leftSub is None and rightSub is None:
return True
# One of them is null, so they aren't mirror images
if leftSub is None or rightSub is None or leftSub.data != rightSub.data:
return False
# Check if the subtrees are mirrors
return isMirror(leftSub.left, rightSub.right) and \
isMirror(leftSub.right, rightSub.left)
def isSymmetric(root):
# If tree is empty, it's symmetric
if root is None:
return True
# Check if the left and right subtrees are mirrors of each other
return isMirror(root.left, root.right)
if __name__ == "__main__":
# Creating a sample symmetric binary tree
# 1
# / \
# 2 2
# / \ / \
# 3 4 4 3
root = Node(1)
root.left = Node(2)
root.right = Node(2)
root.left.left = Node(3)
root.left.right = Node(4)
root.right.left = Node(4)
root.right.right = Node(3)
print("true" if isSymmetric(root) else "false")
// C# program to check if a given Binary
// Tree is symmetric
using System;
class Node {
public int data;
public Node left, right;
public Node(int val) {
data = val;
left = right = null;
}
}
class GfG {
// Recursive helper function to check if two subtrees are mirror images
static bool isMirror(Node leftSub, Node rightSub) {
// Both are null, so they are mirror images
if (leftSub == null && rightSub == null)
return true;
// One of them is null, so they aren't mirror images
if (leftSub == null || rightSub == null ||
leftSub.data != rightSub.data)
return false;
// Check if the subtrees are mirrors
return isMirror(leftSub.left, rightSub.right) &&
isMirror(leftSub.right, rightSub.left);
}
static bool isSymmetric(Node root) {
// If tree is empty, it's symmetric
if (root == null)
return true;
// Check if the left and right subtrees are mirrors of each other
return isMirror(root.left, root.right);
}
static void Main(string[] args) {
// Creating a sample symmetric binary tree
// 1
// / \
// 2 2
// / \ / \
// 3 4 4 3
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(2);
root.left.left = new Node(3);
root.left.right = new Node(4);
root.right.left = new Node(4);
root.right.right = new Node(3);
Console.WriteLine(isSymmetric(root) ? "true" : "false");
}
}
// JavaScript program to check if a given
// Binary Tree is symmetric
class Node {
constructor(data) {
this.data = data;
this.left = null;
this.right = null;
}
}
// Recursive helper function to check if two subtrees are mirror images
function isMirror(leftSub, rightSub) {
// Both are null, so they are mirror images
if (leftSub === null && rightSub === null)
return true;
// One of them is null, so they aren't mirror images
if (leftSub === null || rightSub === null || leftSub.data !== rightSub.data)
return false;
// Check if the subtrees are mirrors
return isMirror(leftSub.left, rightSub.right) &&
isMirror(leftSub.right, rightSub.left);
}
function isSymmetric(root) {
// If tree is empty, it's symmetric
if (root === null)
return true;
// Check if the left and right subtrees are mirrors of each other
return isMirror(root.left, root.right);
}
// Creating a sample symmetric binary tree
// 1
// / \
// 2 2
// / \ / \
// 3 4 4 3
const root = new Node(1);
root.left = new Node(2);
root.right = new Node(2);
root.left.left = new Node(3);
root.left.right = new Node(4);
root.right.left = new Node(4);
root.right.right = new Node(3);
console.log(isSymmetric(root) ? "true" : "false");
Output
true
[Approach - 2] Using Stack - O(n) Time and O(h) Space
The idea is to use two stack to check if a binary tree is symmetric. One stack is for the left side of the tree, and the other is for the right side. By comparing nodes from both stack at each level, we can check if the left and right sides are mirror images of each other.
Step-by-Step Implementation:
- Create a two stacks, say s1 and s2 and push the left child of the root node in s1 and right child of the root node into s2.
- While both the stack are not empty, repeat the following steps:
- Pop two nodes from the stack, say node1 and node2.
- If both node1 and node2 are null, continue to the next iteration.
- If one of the nodes is null and the other is not, return false as it is not a mirror.
- If both nodes are not null, compare their values. If they are not equal, return false.
- Push the left child of node1 and the right child of node2 onto the stack.
- Push the right child of node1 and the left child of node2 onto the stack.
- If the loop completes successfully without returning false, return true as it is a mirror.
// C++ program to check if a given Binary
// Tree is symmetric
#include <iostream>
#include <stack>
using namespace std;
class Node {
public:
int data;
Node *left, *right;
Node(int val) {
data = val;
left = right = nullptr;
}
};
// Function to check if the binary tree is symmetric
bool isSymmetric(Node* root) {
if (root == nullptr)
return true;
// Two stacks to store nodes for comparison
stack<Node*> s1, s2;
// Initialize the stacks with the left
// and right subtrees
s1.push(root->left);
s2.push(root->right);
while (!s1.empty() && !s2.empty()) {
// Get the current pair of nodes
Node* node1 = s1.top();
Node* node2 = s2.top();
s1.pop();
s2.pop();
// If both nodes are null, continue to the next pair
if (node1 == nullptr && node2 == nullptr) {
continue;
}
// If one node is null and the other is not,
// or the nodes' data do not match
// then the tree is not symmetric
if (node1 == nullptr || node2 == nullptr
|| node1->data != node2->data) {
return false;
}
// Push children of node1 and node2 in opposite order
// Push left child of node1 and right child of node2
s1.push(node1->left);
s2.push(node2->right);
// Push right child of node1 and left child of node2
s1.push(node1->right);
s2.push(node2->left);
}
// If both stacks are empty, the tree is symmetric
return s1.empty() && s2.empty();
}
int main() {
// Creating a sample symmetric binary tree
// 1
// / \
// 2 2
// / \ / \
// 3 4 4 3
Node* root = new Node(1);
root->left = new Node(2);
root->right = new Node(2);
root->left->left = new Node(3);
root->left->right = new Node(4);
root->right->left = new Node(4);
root->right->right = new Node(3);
if(isSymmetric(root))
cout << "true";
else
cout << "false";
return 0;
}
// Java program to check if a given Binary
// Tree is symmetric
import java.util.Stack;
class Node {
int data;
Node left, right;
Node(int val) {
data = val;
left = right = null;
}
}
class GfG {
// Function to check if the binary tree is symmetric
static boolean isSymmetric(Node root) {
if (root == null) {
return true;
}
// Two stacks to store nodes for comparison
Stack<Node> s1 = new Stack<>();
Stack<Node> s2 = new Stack<>();
// Initialize the stacks with the left
// and right subtrees
s1.push(root.left);
s2.push(root.right);
while (!s1.isEmpty() && !s2.isEmpty()) {
// Get the current pair of nodes
Node node1 = s1.pop();
Node node2 = s2.pop();
// If both nodes are null, continue to the next pair
if (node1 == null && node2 == null) {
continue;
}
// If one node is null and the other is not,
// or the nodes' data do not match
// then the tree is not symmetric
if (node1 == null || node2 == null
|| node1.data != node2.data) {
return false;
}
// Push children of node1 and node2 in opposite order
// Push left child of node1 and right child of node2
s1.push(node1.left);
s2.push(node2.right);
// Push right child of node1 and left child of node2
s1.push(node1.right);
s2.push(node2.left);
}
// If both stacks are empty, the tree is symmetric
return s1.isEmpty() && s2.isEmpty();
}
public static void main(String[] args) {
// Creating a sample symmetric binary tree
// 1
// / \
// 2 2
// / \ / \
// 3 4 4 3
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(2);
root.left.left = new Node(3);
root.left.right = new Node(4);
root.right.left = new Node(4);
root.right.right = new Node(3);
System.out.println(isSymmetric(root));
}
}
# Python program to check if a given
# Binary Tree is symmetric
class Node:
def __init__(self, val):
self.data = val
self.left = self.right = None
# Function to check if the binary tree is symmetric
def isSymmetric(root):
if root is None:
return True
# Two stacks to store nodes for comparison
s1 = []
s2 = []
# Initialize the stacks with the
# left and right subtrees
s1.append(root.left)
s2.append(root.right)
while s1 and s2:
# Get the current pair of nodes
node1 = s1.pop()
node2 = s2.pop()
# If both nodes are null, continue to the next pair
if node1 is None and node2 is None:
continue
# If one node is null and the other is not,
# or the nodes' data do not match
# then the tree is not symmetric
if node1 is None or node2 is None or node1.data != node2.data:
return False
# Push children of node1 and node2 in opposite order
# Push left child of node1 and right child of node2
s1.append(node1.left)
s2.append(node2.right)
# Push right child of node1 and left child of node2
s1.append(node1.right)
s2.append(node2.left)
# If both stacks are empty, the tree is symmetric
return len(s1) == 0 and len(s2) == 0
if __name__ == "__main__":
# Creating a sample symmetric binary tree
# 1
# / \
# 2 2
# / \ / \
# 3 4 4 3
root = Node(1)
root.left = Node(2)
root.right = Node(2)
root.left.left = Node(3)
root.left.right = Node(4)
root.right.left = Node(4)
root.right.right = Node(3)
print(isSymmetric(root))
// C# program to check if a given Binary
// Tree is symmetric
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left, right;
public Node(int val) {
data = val;
left = right = null;
}
}
class GfG {
// Function to check if the binary tree is symmetric
static bool isSymmetric(Node root) {
if (root == null) {
return true;
}
// Two stacks to store nodes for comparison
Stack<Node> s1 = new Stack<Node>();
Stack<Node> s2 = new Stack<Node>();
// Initialize the stacks with the left
// and right subtrees
s1.Push(root.left);
s2.Push(root.right);
while (s1.Count > 0 && s2.Count > 0) {
// Get the current pair of nodes
Node node1 = s1.Pop();
Node node2 = s2.Pop();
// If both nodes are null, continue to the next pair
if (node1 == null && node2 == null) {
continue;
}
// If one node is null and the other is not,
// or the nodes' data do not match
// then the tree is not symmetric
if (node1 == null || node2 == null
|| node1.data != node2.data) {
return false;
}
// Push children of node1 and node2 in opposite order
// Push left child of node1 and right child of node2
s1.Push(node1.left);
s2.Push(node2.right);
// Push right child of node1 and left child of node2
s1.Push(node1.right);
s2.Push(node2.left);
}
// If both stacks are empty, the tree is symmetric
return s1.Count == 0 && s2.Count == 0;
}
static void Main(string[] args) {
// Creating a sample symmetric binary tree
// 1
// / \
// 2 2
// / \ / \
// 3 4 4 3
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(2);
root.left.left = new Node(3);
root.left.right = new Node(4);
root.right.left = new Node(4);
root.right.right = new Node(3);
Console.WriteLine(isSymmetric(root));
}
}
// JavaScript program to check if a
// given Binary Tree is symmetric
class Node {
constructor(val) {
this.data = val;
this.left = this.right = null;
}
}
// Function to check if the binary tree is symmetric
function isSymmetric(root) {
if (root === null) {
return true;
}
// Two stacks to store nodes for comparison
let s1 = [];
let s2 = [];
// Initialize the stacks with the
// left and right subtrees
s1.push(root.left);
s2.push(root.right);
while (s1.length > 0 && s2.length > 0) {
// Get the current pair of nodes
let node1 = s1.pop();
let node2 = s2.pop();
// If both nodes are null, continue to the next pair
if (node1 === null && node2 === null) {
continue;
}
// If one node is null and the other is not,
// or the nodes' data do not match
// then the tree is not symmetric
if (node1 === null || node2 === null
|| node1.data !== node2.data) {
return false;
}
// Push children of node1 and node2 in opposite order
// Push left child of node1 and right child of node2
s1.push(node1.left);
s2.push(node2.right);
// Push right child of node1 and left child of node2
s1.push(node1.right);
s2.push(node2.left);
}
// If both stacks are empty, the tree is symmetric
return s1.length === 0 && s2.length === 0;
}
// Creating a sample symmetric binary tree
// 1
// / \
// 2 2
// / \ / \
// 3 4 4 3
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(2);
root.left.left = new Node(3);
root.left.right = new Node(4);
root.right.left = new Node(4);
root.right.right = new Node(3);
console.log(isSymmetric(root));
Output
true
[Approach - 3] Using Queue - O(n) Time and O(n) Space
The basic idea is to check if the left and right subtrees of the root node are mirror images of each other. To do this, we perform a level-order traversal of the binary tree using a queue. Initially, we push the root node into the queue twice. We dequeue two nodes at a time from the front of the queue and check if they are mirror images of each other.
Step-by-Step implementation:
- If the root node is NULL, return true as an empty binary tree is considered symmetric.
- Create a queue and push the left and right child of root node into the queue.
- While the queue is not empty, dequeue two nodes at a time, one for the left subtree and one for the right subtree.
- If both the left and right nodes are NULL, continue to the next iteration as the subtrees are considered mirror images of each other.
- If either the left or right node is NULL, or their data is not equal, return false as they are not mirror images of each other.
- Push the left and right nodes of the left subtree into the queue, followed by the right and left nodes of the right subtree into the queue.
- If the queue becomes empty and we have not returned false till now, return true as the binary tree is symmetric.
// C++ program to check if a given Binary
// Tree is symmetric
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int data;
Node *left, *right;
Node(int val) {
data = val;
left = right = nullptr;
}
};
// Function to check if the binary tree is symmetric
bool isSymmetric(Node* root) {
if (root == nullptr) {
return true;
}
// Use a queue to store nodes for comparison
queue<Node*> q;
// Initialize the queue with the left
// and right subtrees
q.push(root->left);
q.push(root->right);
while (!q.empty()) {
Node* node1 = q.front();
q.pop();
Node* node2 = q.front();
q.pop();
// If both nodes are null, continue to the next pair
if (node1 == nullptr && node2 == nullptr) {
continue;
}
// If one node is null and the other is not,
// or the nodes' data do not match
// then the tree is not symmetric
if (node1 == nullptr || node2 == nullptr ||
node1->data != node2->data) {
return false;
}
// Enqueue children in opposite
// order to compare them
q.push(node1->left);
q.push(node2->right);
q.push(node1->right);
q.push(node2->left);
}
// If the loop completes without
// returning false, the tree is symmetric
return true;
}
int main() {
// Creating a sample symmetric binary tree
// 1
// / \
// 2 2
// / \ / \
// 3 4 4 3
Node* root = new Node(1);
root->left = new Node(2);
root->right = new Node(2);
root->left->left = new Node(3);
root->left->right = new Node(4);
root->right->left = new Node(4);
root->right->right = new Node(3);
if(isSymmetric(root)) {
cout << "true";
}
else cout << "false";
return 0;
}
// Java program to check if a given
// Binary Tree is symmetric
import java.util.LinkedList;
import java.util.Queue;
class Node {
int data;
Node left, right;
Node(int val) {
data = val;
left = right = null;
}
}
class GfG {
// Function to check if the binary tree is symmetric
static boolean isSymmetric(Node root) {
if (root == null) {
return true;
}
// Use a queue to store nodes for comparison
Queue<Node> q = new LinkedList<>();
// Initialize the queue with the left and right subtrees
q.offer(root.left);
q.offer(root.right);
while (!q.isEmpty()) {
Node node1 = q.poll();
Node node2 = q.poll();
// If both nodes are null, continue to the next pair
if (node1 == null && node2 == null) {
continue;
}
// If one node is null and the other is not,
// or the nodes' data do not match
// then the tree is not symmetric
if (node1 == null || node2 == null ||
node1.data != node2.data) {
return false;
}
// Enqueue children in opposite order to compare them
q.offer(node1.left);
q.offer(node2.right);
q.offer(node1.right);
q.offer(node2.left);
}
// If the loop completes without
// returning false, the tree is symmetric
return true;
}
public static void main(String[] args) {
// Creating a sample symmetric binary tree
// 1
// / \
// 2 2
// / \ / \
// 3 4 4 3
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(2);
root.left.left = new Node(3);
root.left.right = new Node(4);
root.right.left = new Node(4);
root.right.right = new Node(3);
if (isSymmetric(root))
System.out.println("true");
else
System.out.println("false");
}
}
from collections import deque
# Definition for a binary tree node
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
# Function to check if the binary tree is symmetric
def isSymmetric(root):
if root is None:
return True
# Use a queue to store nodes for comparison
q = deque()
# Initialize the queue with the left and right subtrees
q.append(root.left)
q.append(root.right)
while q:
node1 = q.popleft()
node2 = q.popleft()
# If both nodes are None, continue
if node1 is None and node2 is None:
continue
# If only one is None or values don't match, it's not symmetric
if node1 is None or node2 is None or node1.val != node2.val:
return False
# Enqueue children in opposite order
q.append(node1.left)
q.append(node2.right)
q.append(node1.right)
q.append(node2.left)
return True
if __name__ == "__main__":
# Example symmetric tree
# 1
# / \
# 2 2
# / \ / \
# 3 4 4 3
root = TreeNode(1)
root.left = TreeNode(2, TreeNode(3), TreeNode(4))
root.right = TreeNode(2, TreeNode(4), TreeNode(3))
print("true" if isSymmetric(root) else "false")
// C# program to check if a given Binary
// Tree is symmetric
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left, right;
public Node(int val) {
data = val;
left = right = null;
}
}
class GfG {
// Function to check if the binary tree is symmetric
static bool IsSymmetric(Node root) {
if (root == null) {
return true;
}
// Use a queue to store nodes for comparison
Queue<Node> q = new Queue<Node>();
// Initialize the queue with the
// left and right subtrees
q.Enqueue(root.left);
q.Enqueue(root.right);
while (q.Count > 0) {
Node node1 = q.Dequeue();
Node node2 = q.Dequeue();
// If both nodes are null,
// continue to the next pair
if (node1 == null && node2 == null) {
continue;
}
// If one node is null and the other is not,
// or the nodes' data do not match
// then the tree is not symmetric
if (node1 == null || node2 == null ||
node1.data != node2.data) {
return false;
}
// Enqueue children in opposite
// order to compare them
q.Enqueue(node1.left);
q.Enqueue(node2.right);
q.Enqueue(node1.right);
q.Enqueue(node2.left);
}
// If the loop completes without
// returning false, the tree is symmetric
return true;
}
static void Main() {
// Creating a sample symmetric binary tree
// 1
// / \
// 2 2
// / \ / \
// 3 4 4 3
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(2);
root.left.left = new Node(3);
root.left.right = new Node(4);
root.right.left = new Node(4);
root.right.right = new Node(3);
Console.WriteLine(isSymmetric(root) ? "true" : "false");
}
}
// JavaScript program to check if a given
// Binary Tree is symmetric
class Node {
constructor(val) {
this.data = val;
this.left = this.right = null;
}
}
// Function to check if the binary tree is symmetric
function isSymmetric(root) {
if (root === null) {
return true;
}
// Use a queue to store nodes for comparison
const q = [];
// Initialize the queue with the left
// and right subtrees
q.push(root.left);
q.push(root.right);
while (q.length > 0) {
const node1 = q.shift();
const node2 = q.shift();
// If both nodes are null,
// continue to the next pair
if (node1 === null && node2 === null) {
continue;
}
// If one node is null and the other is not,
// or the nodes' data do not match
// then the tree is not symmetric
if (node1 === null || node2 === null ||
node1.data !== node2.data) {
return false;
}
// Enqueue children in opposite
// order to compare them
q.push(node1.left);
q.push(node2.right);
q.push(node1.right);
q.push(node2.left);
}
// If the loop completes without
// returning false, the tree is symmetric
return true;
}
// Creating a sample symmetric binary tree
// 1
// / \
// 2 2
// / \ / \
// 3 4 4 3
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(2);
root.left.left = new Node(3);
root.left.right = new Node(4);
root.right.left = new Node(4);
root.right.right = new Node(3);
console.log(isSymmetric(root) ? "true" : "false");
Output
True
