GFG App
Open App
Browser
Continue

# Check if two trees are Mirror

Given two Binary Trees, write a function that returns true if two trees are mirror of each other, else false. For example, the function should return true for following input trees.

This problem is different from the problem discussed here.
For two trees ‘a’ and ‘b’ to be mirror images, the following three conditions must be true:

1. Their root node’s key must be same
2. Left subtree of root of ‘a’ and right subtree root of ‘b’ are mirror.
3. Right subtree of ‘a’ and left subtree of ‘b’ are mirror.

Below is implementation of above idea.

## C++

 `// C++ program to check if two trees are mirror` `// of each other` `#include` `using` `namespace` `std;`   `/* A binary tree node has data, pointer to` `   ``left child and a pointer to right child */` `struct` `Node` `{` `    ``int` `data;` `    ``Node* left, *right;` `};`   `/* Given two trees, return true if they are` `   ``mirror of each other */` `/*As function has to return bool value instead integer value*/` `bool` `areMirror(Node* a, Node* b)` `{` `    ``/* Base case : Both empty */` `    ``if` `(a==NULL && b==NULL)` `        ``return` `true``;`   `    ``// If only one is empty` `    ``if` `(a==NULL || b == NULL)` `        ``return` `false``;`   `    ``/* Both non-empty, compare them recursively` `     ``Note that in recursive calls, we pass left` `     ``of one tree and right of other tree */` `    ``return`  `a->data == b->data &&` `            ``areMirror(a->left, b->right) &&` `            ``areMirror(a->right, b->left);` `}`   `/* Helper function that allocates a new node */` `Node* newNode(``int` `data)` `{` `    ``Node* node = ``new` `Node;` `    ``node->data  = data;` `    ``node->left  =  node->right  = NULL;` `    ``return``(node);` `}`   `/* Driver program to test areMirror() */` `int` `main()` `{` `    ``Node *a = newNode(1);` `    ``Node *b = newNode(1);` `    ``a->left = newNode(2);` `    ``a->right = newNode(3);` `    ``a->left->left  = newNode(4);` `    ``a->left->right = newNode(5);`   `    ``b->left = newNode(3);` `    ``b->right = newNode(2);` `    ``b->right->left = newNode(5);` `    ``b->right->right = newNode(4);`   `    ``areMirror(a, b)? cout << ``"Yes"` `: cout << ``"No"``;`   `    ``return` `0;` `}`

## Java

 `// Java program to see if two trees ` `// are mirror of each other`   `// A binary tree node` `class` `Node ` `{` `    ``int` `data;` `    ``Node left, right;`   `    ``public` `Node(``int` `data)` `    ``{` `        ``this``.data = data;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `BinaryTree ` `{` `    ``Node a, b;` `    `  `    ``/* Given two trees, return true if they are` `       ``mirror of each other */` `    ``boolean` `areMirror(Node a, Node b) ` `    ``{` `        ``/* Base case : Both empty */` `        ``if` `(a == ``null` `&& b == ``null``)` `            ``return` `true``;`   `        ``// If only one is empty` `        ``if` `(a == ``null` `|| b == ``null``) ` `            ``return` `false``;`   `        ``/* Both non-empty, compare them recursively` `           ``Note that in recursive calls, we pass left` `           ``of one tree and right of other tree */` `        ``return` `a.data == b.data` `                ``&& areMirror(a.left, b.right)` `                ``&& areMirror(a.right, b.left);` `    ``}`   `    ``// Driver code to test above methods` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``BinaryTree tree = ``new` `BinaryTree();` `        ``Node a = ``new` `Node(``1``);` `        ``Node b = ``new` `Node(``1``);` `        ``a.left = ``new` `Node(``2``);` `        ``a.right = ``new` `Node(``3``);` `        ``a.left.left = ``new` `Node(``4``);` `        ``a.left.right = ``new` `Node(``5``);`   `        ``b.left = ``new` `Node(``3``);` `        ``b.right = ``new` `Node(``2``);` `        ``b.right.left = ``new` `Node(``5``);` `        ``b.right.right = ``new` `Node(``4``);`   `        ``if` `(tree.areMirror(a, b) == ``true``)` `            ``System.out.println(``"Yes"``);` `        ``else` `            ``System.out.println(``"No"``);`   `    ``}` `}`   `// This code has been contributed by Mayank Jaiswal(mayank_24)`

## Python3

 `# Python3 program to check if two` `# trees are mirror of each other`   `# A binary tree node` `class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# Given two trees, return true ` `# if they are mirror of each other` `def` `areMirror(a, b):` `    `  `    ``# Base case : Both empty` `    ``if` `a ``is` `None` `and` `b ``is` `None``:` `        ``return` `True` `    `  `    ``# If only one is empty` `    ``if` `a ``is` `None` `or` `b ``is` `None``:` `        ``return` `False` `    `  `    ``# Both non-empty, compare them ` `    ``# recursively. Note that in ` `    ``# recursive calls, we pass left` `    ``# of one tree and right of other tree` `    ``return` `(a.data ``=``=` `b.data ``and` `            ``areMirror(a.left, b.right) ``and` `            ``areMirror(a.right , b.left))`   `# Driver code` `root1 ``=` `Node(``1``)` `root2 ``=` `Node(``1``)`   `root1.left ``=` `Node(``2``)` `root1.right ``=` `Node(``3``)` `root1.left.left ``=` `Node(``4``)` `root1.left.right ``=` `Node(``5``)`   `root2.left ``=` `Node(``3``)` `root2.right ``=` `Node(``2``)` `root2.right.left ``=` `Node(``5``)` `root2.right.right ``=` `Node(``4``)`   `if` `areMirror(root1, root2):` `    ``print` `(``"Yes"``)` `else``:` `    ``print` `(``"No"``)`   `# This code is contributed by AshishR`

## C#

 `using` `System;`   `// c# program to see if two trees ` `// are mirror of each other `   `// A binary tree node ` `public` `class` `Node` `{` `    ``public` `int` `data;` `    ``public` `Node left, right;`   `    ``public` `Node(``int` `data)` `    ``{` `        ``this``.data = data;` `        ``left = right = ``null``;` `    ``}` `}`   `public` `class` `BinaryTree` `{` `    ``public` `Node a, b;`   `    ``/* Given two trees, return true if they are ` `    ``mirror of each other */` `    ``public` `virtual` `bool` `areMirror(Node a, Node b)` `    ``{` `        ``/* Base case : Both empty */` `        ``if` `(a == ``null` `&& b == ``null``)` `        ``{` `            ``return` `true``;` `        ``}`   `        ``// If only one is empty ` `        ``if` `(a == ``null` `|| b == ``null``)` `        ``{` `            ``return` `false``;` `        ``}`   `        ``/* Both non-empty, compare them recursively ` `        ``Note that in recursive calls, we pass left ` `        ``of one tree and right of other tree */` `        ``return` `a.data == b.data && areMirror(a.left, b.right) ` `                            ``&& areMirror(a.right, b.left);` `    ``}`   `    ``// Driver code to test above methods ` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``BinaryTree tree = ``new` `BinaryTree();` `        ``Node a = ``new` `Node(1);` `        ``Node b = ``new` `Node(1);` `        ``a.left = ``new` `Node(2);` `        ``a.right = ``new` `Node(3);` `        ``a.left.left = ``new` `Node(4);` `        ``a.left.right = ``new` `Node(5);`   `        ``b.left = ``new` `Node(3);` `        ``b.right = ``new` `Node(2);` `        ``b.right.left = ``new` `Node(5);` `        ``b.right.right = ``new` `Node(4);`   `        ``if` `(tree.areMirror(a, b) == ``true``)` `        ``{` `            ``Console.WriteLine(``"Yes"``);` `        ``}` `        ``else` `        ``{` `            ``Console.WriteLine(``"No"``);` `        ``}`   `    ``}` `}`   `// This code is contributed by Shrikant13`

## Javascript

 ``

Output

`Yes`

Time Complexity: O(n)
Auxiliary Space: O(h) where h is height of binary tree

Approach 2: Iterative Solution

Another approach to check if two trees are mirrors of each other is to use an iterative algorithm that uses a stack to keep track of the nodes being traversed. This algorithm is similar to the iterative algorithm for checking if a tree is symmetric, but with a slight modification to check for mirror symmetry.

This solution uses two stacks to iterate over the two trees in a synchronized way. It pops a node from both stacks, checks if their data is equal, and then pushes their left and right children onto the stacks in the opposite order. The algorithm terminates early if at any point the nodes being compared have unequal data or unequal numbers of children.

Here is the C++ code for the iterative solution:

## C++

 `#include ` `using` `namespace` `std;`   `// A binary tree node` `class` `Node {` `public``:` `    ``int` `data;` `    ``Node* left;` `    ``Node* right;`   `    ``Node(``int` `d)` `    ``{` `        ``this``->data = d;` `        ``this``->left = NULL;` `        ``this``->right = NULL;` `    ``}` `};`   `bool` `isMirrorIterative(Node* root1, Node* root2)` `{` `    ``if` `(root1 == NULL && root2 == NULL)` `        ``return` `true``;` `    `  `    ``if` `(root1 == NULL || root2 == NULL)` `        ``return` `false``;` `    `  `    ``stack s1, s2;` `    ``s1.push(root1);` `    ``s2.push(root2);` `    `  `    ``while` `(!s1.empty() && !s2.empty())` `    ``{` `        ``Node* curr1 = s1.top();` `        ``s1.pop();` `        ``Node* curr2 = s2.top();` `        ``s2.pop();` `        `  `        ``if` `(curr1->data != curr2->data)` `            ``return` `false``;` `        `  `        ``if` `(curr1->left != NULL && curr2->right != NULL)` `        ``{` `            ``s1.push(curr1->left);` `            ``s2.push(curr2->right);` `        ``}` `        ``else` `if` `(curr1->left != NULL || curr2->right != NULL)` `            ``return` `false``;` `        `  `        ``if` `(curr1->right != NULL && curr2->left != NULL)` `        ``{` `            ``s1.push(curr1->right);` `            ``s2.push(curr2->left);` `        ``}` `        ``else` `if` `(curr1->right != NULL || curr2->left != NULL)` `            ``return` `false``;` `    ``}` `    `  `    ``if` `(!s1.empty() || !s2.empty())` `        ``return` `false``;` `    `  `    ``return` `true``;` `}`   `int` `main()` `{` `    ``// create the two trees` `    ``Node* root1 = ``new` `Node(1);` `    ``root1->left = ``new` `Node(2);` `    ``root1->right = ``new` `Node(3);` `    ``root1->left->left = ``new` `Node(4);` `    ``root1->left->right = ``new` `Node(5);`   `    ``Node* root2 = ``new` `Node(1);` `    ``root2->left = ``new` `Node(3);` `    ``root2->right = ``new` `Node(2);` `    ``root2->right->left = ``new` `Node(5);` `    ``root2->right->right = ``new` `Node(4);` `    `  `    ``// check if the two trees are mirrors` `    ``if` `(isMirrorIterative(root1, root2))` `        ``cout << ``"Yes"` `<< endl;` `    ``else` `        ``cout << ``"No"` `<< endl;` `    `  `    ``return` `0;` `}`

## Java

 `import` `java.util.*;`   `// A binary tree node` `class` `Node {` `int` `data;` `Node left;` `Node right;` `  ``Node(``int` `d) {` `    ``this``.data = d;` `    ``this``.left = ``null``;` `    ``this``.right = ``null``;` `}` `}`   `class` `Main {` `static` `boolean` `isMirrorIterative(Node root1, Node root2) {` `if` `(root1 == ``null` `&& root2 == ``null``)` `return` `true``;` `      ``if` `(root1 == ``null` `|| root2 == ``null``)` `        ``return` `false``;`   `    ``Stack s1 = ``new` `Stack<>();` `    ``Stack s2 = ``new` `Stack<>();` `    ``s1.push(root1);` `    ``s2.push(root2);`   `    ``while` `(!s1.empty() && !s2.empty()) {` `        ``Node curr1 = s1.pop();` `        ``Node curr2 = s2.pop();`   `        ``if` `(curr1.data != curr2.data)` `            ``return` `false``;`   `        ``if` `(curr1.left != ``null` `&& curr2.right != ``null``) {` `            ``s1.push(curr1.left);` `            ``s2.push(curr2.right);` `        ``} ``else` `if` `(curr1.left != ``null` `|| curr2.right != ``null``)` `            ``return` `false``;`   `        ``if` `(curr1.right != ``null` `&& curr2.left != ``null``) {` `            ``s1.push(curr1.right);` `            ``s2.push(curr2.left);` `        ``} ``else` `if` `(curr1.right != ``null` `|| curr2.left != ``null``)` `            ``return` `false``;` `    ``}`   `    ``if` `(!s1.empty() || !s2.empty())` `        ``return` `false``;`   `    ``return` `true``;` `}`   `public` `static` `void` `main(String[] args) {` `    ``// create the two trees` `    ``Node root1 = ``new` `Node(``1``);` `    ``root1.left = ``new` `Node(``2``);` `    ``root1.right = ``new` `Node(``3``);` `    ``root1.left.left = ``new` `Node(``4``);` `    ``root1.left.right = ``new` `Node(``5``);`   `    ``Node root2 = ``new` `Node(``1``);` `    ``root2.left = ``new` `Node(``3``);` `    ``root2.right = ``new` `Node(``2``);` `    ``root2.right.left = ``new` `Node(``5``);` `    ``root2.right.right = ``new` `Node(``4``);`   `    ``// check if the two trees are mirrors` `    ``if` `(isMirrorIterative(root1, root2))` `        ``System.out.println(``"Yes"``);` `    ``else` `        ``System.out.println(``"No"``);` `}` `}`

Output

`Yes`

Time Complexity: O(n)
Auxiliary Space: O(h) where h is height of binary tree