# Given Two Binary Trees, Check if it is Symmetric

## Implementation

``````// creating a C++ program that will help us check whether the two given trees are mirror images of each other.
#include<bits/stdc++.h>
using namespace std;

/* A given binary tree has a data pointer to the left and right child.
*/
struct __nod
{
int record;
__nod* Lft, *Rt;
};

/* if we are given two trees that appear to mirror each other, then we have to return the value true. */
/*Because the function has to return the boolean value instead of the integer one. */
bool mirror(__nod* a, __nod* b)
{
/* The basic case arises when both cases are empty. */
if (a==NILL && b==NILL)
return true;

// If one is empty, then
if (a==NILL || b == NILL)
return false;

/* if both are non-empty, then we have to balance them recursively; when we make a recursive call, we generally pass the left of one tree and the right of another. */
return a->record == b->record &&
areMirror(a->Lft, b->Rt) &&
areMirror(a->Rt, b->Lft);
}

/* We have to create a helper function to help allot a new node. */
__nod* new__nod(int record)
{
__nod* __nod = new __nod;
__nod->record = record;
__nod->Lft = __nod->Rt = NILL;
return(__nod);
}

/* writing the main program to test the above functions */
int main()
{
__nod *a = new__nod(1);
__nod *b = new__nod(1);
a->Lft = new__nod(2);
a->Rt = new__nod(3);
a->Lft->Lft = new__nod(4);
a->Lft->Rt = new__nod(5);

b->Lft = new__nod(3);
b->Rt = new__nod(2);
b->Rt->Lft = new__nod(5);
b->Rt->Rt = new__nod(4);

areMirror(a, b)? cout << "Yes" : cout << "No";

return 0;
}
``````

Output:

Example 2)

``````using System;
// creating a C++ program that will help us check whether the two given trees are mirror images of each other.
/* A given binary tree has a data pointer to the left and right child.
*/
public class __nod
{
public int record;
public __nod Lft, Rt;

public __nod(int record)
{
this.record = record;
Lft = Rt = NILL;
}
}

public class BinaryTree
{
public __nod a, b;
/* if we are given two trees, which appear to mirror each other, then we have to return the value true. */
public virtual bool mirror(__nod a, __nod b)
{
/* The basic case arises when both cases are empty. */
if (a == NILL && b == NILL)
{
return true;
}

// If only one is empty
if (a == NILL || b == NILL)
{
return false;
}
/* if both are non-empty, then we have to balance them recursively; when we make a recursive call, we generally pass the left of one tree and the right of another. */
return a.record == b.record && areMirror(a.Lft, b.Rt)
&& areMirror(a.Rt, b.Lft);
}
/* writing the main program to test the above functions */
public static void Main(string[] args)
{
BinaryTree tree = new BinaryTree();
__nod a = new __nod(1);
__nod b = new __nod(1);
a.Lft = new __nod(2);
a.Rt = new __nod(3);
a.Lft.Lft = new __nod(4);
a.Lft.Rt = new __nod(5);

b.Lft = new __nod(3);
b.Rt = new __nod(2);
b.Rt.Lft = new __nod(5);
b.Rt.Rt = new __nod(4);

if (tree.areMirror(a, b) == true)
{
Console.WriteLine("Yes");
}
else
{
Console.WriteLine("No");
}

}
}
``````

Output:

Example 3)

``````// creating a Java program that will help us check whether the two given trees are mirror images of each other.
/* A given binary tree has a data pointer to the left and right child.
*/
class __nod
{
int record;
__nod Lft, Rt;

public __nod(int record)
{
this.record = record;
Lft = Rt = NILL;
}
}

class BinaryTree
{
__nod a, b;
/* if we are given two trees, which appear to mirror each other, then we have to return the value true. */
boolean mirror(__nod a, __nod b)
{
/* The basic case arises when both cases are empty. */
if (a == NILL && b == NILL)
return true;

// If only one is empty
if (a == NILL || b == NILL)
return false;
/* if both are non-empty, then we have to balance them recursively; when we make a recursive call, we generally pass the left of one tree and the right of another. */
return a.record == b.record
&& areMirror(a.Lft, b.Rt)
&& areMirror(a.Rt, b.Lft);
}
/* writing the main program to test the above functions */
public static void main(String[] args)
{
BinaryTree tree = new BinaryTree();
__nod a = new __nod(1);
__nod b = new __nod(1);
a.Lft = new __nod(2);
a.Rt = new __nod(3);
a.Lft.Lft = new __nod(4);
a.Lft.Rt = new __nod(5);

b.Lft = new __nod(3);
b.Rt = new __nod(2);
b.Rt.Lft = new __nod(5);
b.Rt.Rt = new __nod(4);

if (tree.areMirror(a, b) == true)
System.out.println("Yes");
else
System.out.println("No");

}
}
``````

Output:

Example 4)

``````# creating a Python program that will help us check whether the two given trees are mirror images of each other.
# A given binary tree has a data pointer to the left and right child.
class __nod:
def __init__(self, record):
self.record = record
self.Lft = None
self.Rt = None

#  if we are given two trees, and they appear to be mirrors of each other, then we have to return the value true.
def mirror(a, b):

# the basic case arises when both cases are 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

# if both are non-empty, then we have to balance them recursively; when we make a recursive call, we generally pass the left of one tree and the right of another.
return (a.record == b.record and
areMirror(a.Lft, b.Rt) and
areMirror(a.Rt , b.Lft))

# writing the main program to test the above functions
root1 = __nod(1)
root2 = __nod(1)

root1.Lft = __nod(2)
root1.Rt = __nod(3)
root1.Lft.Lft = __nod(4)
root1.Lft.Rt = __nod(5)

root2.Lft = __nod(3)
root2.Rt = __nod(2)
root2.Rt.Lft = __nod(5)
root2.Rt.Rt = __nod(4)

if mirror(root1, root2):
print ("Yes")
Else:
print ("No")
``````

Output:

Example 5)

``````<script>
// creating a JavaScript program that will help us check whether the two given trees are the mirror image of each other.
/* A given binary tree has a data pointer to the left and right child.
*/
class __nod {

__nod(record) {
this.record = record;
this.Lft = this.Rt = NILL;
}
}

var a, b;
/* if we are given two trees, which appear to mirror each other, then we have to return the value true. */
function areMirror( a, b) {
/* The basic case arises when both cases are empty. */
if (a == NILL && b == NILL)
return true;

// If only one is empty
if (a == NILL || b == NILL)
return false;
/* if both are non-empty, then we have to balance them recursively; when we make a recursive call, we generally pass the left of one tree and the right of another. */
return a.record == b.record && areMirror(a.Lft, b.Rt) && areMirror(a.Rt, b.Lft);
}
/* writing the main program to test the above functions */
a = new __nod(1);
b = new __nod(1);
Lft = new __nod(2);
Rt = new __nod(3);
Lft.Lft = new __nod(4);
Lft.Rt = new __nod(5);

Lft = new __nod(3);
Rt = new __nod(2);
Rt.Lft = new __nod(5);
Rt.Rt = new __nod(4);

if (areMirror(a, b) == true)
document.write("Yes");
else
document.write("No");
</script>
``````

Output: