Symmetric Tree (Mirror Image of itself)

// C# program to check is binary
// tree is symmetric or not
using System;

class Node {
    public int key;
    public Node left, right;

    public Node(int item)
    {
        key = item;
        left = right = null;
    }
}

class GFG {
    Node root;

    // returns true if trees with roots
    // as root1 and root2 are mirror
    Boolean isMirror(Node node1, Node node2)
    {
        // if both trees are empty,
        // then they are mirror image
        if (node1 == null && node2 == null)
            return true;

        // For two trees to be mirror images,
        // the following three conditions must be true
        // 1 - Their root node's key must be same
        // 2 - left subtree of left tree and right 
        // subtree of right tree have to be mirror images
        // 3 - right subtree of left tree and left subtree
        // of right tree have to be mirror images
        if (node1 != null && node2 != null
            && node1.key == node2.key)
            return (isMirror(node1.left, node2.right)
                    && isMirror(node1.right, node2.left));

        // if none of the above conditions
        // is true then root1 and root2 are
        // mirror images
        return false;
    }

    // returns true if the tree is symmetric
    // i.e mirror image of itself
    Boolean isSymmetric()
    {
        // check if tree is mirror of itself
        return isMirror(root, root);
    }

    // Driver Code
    static public void Main(String[] args)
    {
        GFG tree = new GFG();
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(2);
        tree.root.left.left = new Node(3);
        tree.root.left.right = new Node(4);
        tree.root.right.left = new Node(4);
        tree.root.right.right = new Node(3);
        Boolean output = tree.isSymmetric();
        if (output == true)
            Console.WriteLine("Symmetric");
        else
            Console.WriteLine("Not symmetric");
    }
}

// This code is contributed by Arnab Kundu

using System;
using System.Collections;

public class Node
{
    public int key;
    public Node left, right;

    // Constructor
    public Node(int item)
    {
        key = item;
        left = right = null;
    }
}

public class GFG
{
    // Returns true if a tree is symmetric i.e. mirror image
    // of itself
    static bool isSymmetric(Node root)
    {
        // If the root is null, then the binary tree is
        // symmetric.
        if (root == null)
        {
            return true;
        }

        // Create a stack to store the left and right subtrees
        // of the root.
        Stack stack = new Stack();
        stack.Push(root.left);
        stack.Push(root.right);

        // Continue the loop until the stack is empty.
        while (stack.Count != 0)
        {
            // Pop the left and right subtrees from the stack.
            Node node1 = (Node)stack.Pop();
            Node node2 = (Node)stack.Pop();

            // If both nodes are null, continue the loop.
            if (node1 == null && node2 == null)
            {
                continue;
            }

            // If one of the nodes is null, the binary tree
            // is not symmetric.
            if (node1 == null || node2 == null)
            {
                return false;
            }

            // If the values of the nodes are not equal, the
            // binary tree is not symmetric.
            if (node1.key != node2.key)
            {
                return false;
            }

            // Push the left and right subtrees of the left
            // and right nodes onto the stack in the
            // opposite order.
            stack.Push(node1.left);
            stack.Push(node2.right);
            stack.Push(node1.right);
            stack.Push(node2.left);
        }

        // If the loop completes, the binary tree is
        // symmetric.
        return true;
    }

    // Driver code
    public static void Main(string[] args)
    {
        // Let us construct the Tree shown in the above
        // figure
        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))
            Console.WriteLine("Symmetric");
        else
            Console.WriteLine("Not symmetric");
    }
}

using System;
using System.Collections.Generic;

public class Node
{
    public int Data;
    public Node Left;
    public Node Right;

    public Node(int val)
    {
        Data = val;
        Left = null;
        Right = null;
    }
}

public class BinaryTree
{
    public static bool IsSymmetric(Node root)
    {
        if (root == null)
        {
            return true;
        }

        Queue<Node> queue = new Queue<Node>();
        queue.Enqueue(root);
        queue.Enqueue(root);

        while (queue.Count > 0)
        {
            Node leftNode = queue.Dequeue();
            Node rightNode = queue.Dequeue();

            // If both leftNode and rightNode are null, continue to the next iteration
            if (leftNode == null && rightNode == null)
            {
                continue;
            }

            // If either leftNode or rightNode is null or their data is not equal, return false
            if (leftNode == null || rightNode == null || leftNode.Data != rightNode.Data)
            {
                return false;
            }

            // Pushing the left and right nodes of the current node into the queue
            queue.Enqueue(leftNode.Left);
            queue.Enqueue(rightNode.Right);
            queue.Enqueue(leftNode.Right);
            queue.Enqueue(rightNode.Left);
        }
        return true;
    }

    public static void Main(string[] args)
    {
        // Creating a binary tree
        Node root = new Node(5);
        root.Left = new Node(1);
        root.Right = new Node(1);
        root.Left.Left = new Node(2);
        root.Right.Right = new Node(2);

        // Checking if the binary tree is symmetric or not
        if (IsSymmetric(root))
        {
            Console.WriteLine("The binary tree is symmetric");
        }
        else
        {
            Console.WriteLine("The binary tree is not symmetric");
        }
    }
}