Given a binary tree, check whether it is a mirror of itself.
Examples:
Input:
5
/ \
3 3
/ \ / \
8 9 9 8
Output: Symmetric
Input:
5
/ \
8 7
\ \
4 3
Output: Not Symmetric
Approach: The idea is to traverse the tree using Morris Traversal and Reverse Morris Traversal to traverse the given binary tree and at each step check that the data of the current node is equal in both the traversals. If at any step the data of the nodes are different. Then, the given tree is not Symmetric Binary Tree.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node* left;
Node* right;
Node( int val)
{
data = val;
left = right = NULL;
}
};
bool isSymmetric( struct Node* root)
{
Node *curr1 = root, *curr2 = root;
while (curr1 != NULL
&& curr2 != NULL) {
if (curr1->left == NULL
&& curr2->right == NULL) {
if (curr1->data != curr2->data)
return false ;
curr1 = curr1->right;
curr2 = curr2->left;
}
else if (curr1->left != NULL
&& curr2->right != NULL) {
Node* pre1 = curr1->left;
Node* pre2 = curr2->right;
while (pre1->right != NULL
&& pre1->right != curr1
&& pre2->left != NULL
&& pre2->left != curr2) {
pre1 = pre1->right;
pre2 = pre2->left;
}
if (pre1->right == NULL
&& pre2->left == NULL) {
pre1->right = curr1;
pre2->left = curr2;
curr1 = curr1->left;
curr2 = curr2->right;
}
else if (pre1->right == curr1
&& pre2->left == curr2) {
pre1->right = NULL;
pre2->left = NULL;
if (curr1->data != curr2->data)
return false ;
curr1 = curr1->right;
curr2 = curr2->left;
}
else
return false ;
}
else
return false ;
}
if (curr1 != curr2)
return false ;
return true ;
}
int main()
{
Node* root = new Node(5);
root->left = new Node(3);
root->right = new Node(3);
root->left->left = new Node(8);
root->left->right = new Node(9);
root->right->left = new Node(9);
root->right->right = new Node(8);
if (isSymmetric(root))
cout << "Symmetric" ;
else
cout << "Not Symmetric" ;
return 0;
}
|
Java
class GFG{
static class Node
{
int data;
Node left;
Node right;
Node( int val)
{
data = val;
left = right = null ;
}
};
static boolean isSymmetric(Node root)
{
Node curr1 = root, curr2 = root;
while (curr1 != null &&
curr2 != null )
{
if (curr1.left == null &&
curr2.right == null )
{
if (curr1.data != curr2.data)
return false ;
curr1 = curr1.right;
curr2 = curr2.left;
}
else if (curr1.left != null &&
curr2.right != null )
{
Node pre1 = curr1.left;
Node pre2 = curr2.right;
while (pre1.right != null &&
pre1.right != curr1 &&
pre2.left != null &&
pre2.left != curr2)
{
pre1 = pre1.right;
pre2 = pre2.left;
}
if (pre1.right == null &&
pre2.left == null )
{
pre1.right = curr1;
pre2.left = curr2;
curr1 = curr1.left;
curr2 = curr2.right;
}
else if (pre1.right == curr1 &&
pre2.left == curr2)
{
pre1.right = null ;
pre2.left = null ;
if (curr1.data != curr2.data)
return false ;
curr1 = curr1.right;
curr2 = curr2.left;
}
else
return false ;
}
else
return false ;
}
if (curr1 != curr2)
return false ;
return true ;
}
public static void main(String[] args)
{
Node root = new Node( 5 );
root.left = new Node( 3 );
root.right = new Node( 3 );
root.left.left = new Node( 8 );
root.left.right = new Node( 9 );
root.right.left = new Node( 9 );
root.right.right = new Node( 8 );
if (isSymmetric(root))
System.out.print( "Symmetric" );
else
System.out.print( "Not Symmetric" );
}
}
|
Python3
class Node:
def __init__( self , val):
self .data = val
self .left = self .right = None
def isSymmetric(root):
curr1 = root
curr2 = root
while curr1 ! = None and curr2 ! = None :
if (curr1.left = = None and
curr2.right = = None ):
if curr1.data ! = curr2.data:
return False
curr1 = curr1.right
curr2 = curr2.left
elif curr1 ! = None and curr2 ! = None :
pre1 = curr1.left
pre2 = curr2.right
while (pre1.right ! = None and
pre1.right ! = curr1 and
pre2.left ! = None and
pre2.left ! = curr2):
pre1 = pre1.right
pre2 = pre2.left
if pre1.right = = None and pre2.left = = None :
pre1.right = curr1
pre2.left = curr2
curr1 = curr1.left
curr2 = curr2.right
elif (pre1.right = = curr1 and
pre2.left = = curr2):
pre1.right = None
pre2.left = None
if curr1.data ! = curr2.data:
return False
curr1 = curr1.right
curr2 = curr2.left
else :
return False
else :
return False
if curr1 ! = curr2:
return False
return True
def main():
root = Node( 5 )
root.left = Node( 3 )
root.right = Node( 3 )
root.left.left = Node( 8 )
root.left.right = Node( 9 )
root.right.left = Node( 9 )
root.right.right = Node( 8 )
if isSymmetric(root):
print ( "Symmetric" )
else :
print ( "Not Symmetric" )
main()
|
C#
using System;
class GFG{
class Node
{
public int data;
public Node left;
public Node right;
public Node( int val)
{
data = val;
left = right = null ;
}
};
static bool isSymmetric(Node root)
{
Node curr1 = root, curr2 = root;
while (curr1 != null &&
curr2 != null )
{
if (curr1.left == null &&
curr2.right == null )
{
if (curr1.data != curr2.data)
return false ;
curr1 = curr1.right;
curr2 = curr2.left;
}
else if (curr1.left != null &&
curr2.right != null )
{
Node pre1 = curr1.left;
Node pre2 = curr2.right;
while (pre1.right != null &&
pre1.right != curr1 &&
pre2.left != null &&
pre2.left != curr2)
{
pre1 = pre1.right;
pre2 = pre2.left;
}
if (pre1.right == null &&
pre2.left == null )
{
pre1.right = curr1;
pre2.left = curr2;
curr1 = curr1.left;
curr2 = curr2.right;
}
else if (pre1.right == curr1 &&
pre2.left == curr2)
{
pre1.right = null ;
pre2.left = null ;
if (curr1.data != curr2.data)
return false ;
curr1 = curr1.right;
curr2 = curr2.left;
}
else
return false ;
}
else
return false ;
}
if (curr1 != curr2)
return false ;
return true ;
}
public static void Main(String[] args)
{
Node root = new Node(5);
root.left = new Node(3);
root.right = new Node(3);
root.left.left = new Node(8);
root.left.right = new Node(9);
root.right.left = new Node(9);
root.right.right = new Node(8);
if (isSymmetric(root))
Console.Write( "Symmetric" );
else
Console.Write( "Not Symmetric" );
}
}
|
Javascript
<script>
class Node
{
constructor(val) {
this .left = null ;
this .right = null ;
this .data = val;
}
}
function isSymmetric(root)
{
let curr1 = root, curr2 = root;
while (curr1 != null &&
curr2 != null )
{
if (curr1.left == null &&
curr2.right == null )
{
if (curr1.data != curr2.data)
return false ;
curr1 = curr1.right;
curr2 = curr2.left;
}
else if (curr1.left != null &&
curr2.right != null )
{
let pre1 = curr1.left;
let pre2 = curr2.right;
while (pre1.right != null &&
pre1.right != curr1 &&
pre2.left != null &&
pre2.left != curr2)
{
pre1 = pre1.right;
pre2 = pre2.left;
}
if (pre1.right == null &&
pre2.left == null )
{
pre1.right = curr1;
pre2.left = curr2;
curr1 = curr1.left;
curr2 = curr2.right;
}
else if (pre1.right == curr1 &&
pre2.left == curr2)
{
pre1.right = null ;
pre2.left = null ;
if (curr1.data != curr2.data)
return false ;
curr1 = curr1.right;
curr2 = curr2.left;
}
else
return false ;
}
else
return false ;
}
if (curr1 != curr2)
return false ;
return true ;
}
let root = new Node(5);
root.left = new Node(3);
root.right = new Node(3);
root.left.left = new Node(8);
root.left.right = new Node(9);
root.right.left = new Node(9);
root.right.right = new Node(8);
if (isSymmetric(root))
document.write( "Symmetric" );
else
document.write( "Not Symmetric" );
</script>
|
Output:
Symmetric
Time Complexity: Since every edge of the tree is traversed at most two times exactly as in the case of Morris traversal and in the worst case, the same number of extra edges (as input tree) are created and removed. Therefore, the time complexity of this approach is O(N).
Auxiliary Space: O(1)
Last Updated :
21 Jun, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...