[GeeksForGeeks] Check for symmetric binary tree

Given a binary tree, check whether it is a mirror of itself using both recursion and iterative approach.

Examples:

Input :   
    
     1
   /   
  2     2
 /    / 
3   4 4   3

Output : Symmetric

Input :    
   
    1
   / 
  2   2
      
   3    3

Output : Not Symmetric

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

public class SymmetricBt {
    public static boolean checkIfSymRecursion(TreeNode root) {
        return isSymRecursionHelper(root, root);
    }
    private static boolean isSymRecursionHelper(TreeNode n1, TreeNode n2) {
        if(n1 == null && n2 == null) {
            return true;
        }
        if(n1 != null && n2 != null && n1.val == n2.val) {
            return isSymRecursionHelper(n1.left, n2.right) && isSymRecursionHelper(n1.right, n2.left);
        }
        return false;
    }
    public static boolean checkIfSymIterative(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        
        while(!queue.isEmpty()) {
            if(!isPalindrome(queue)) {
                return false;
            }
            int size = queue.size();
            for(int i = 0; i < size; i++) {
                TreeNode curr = queue.poll();
                if(curr != null) {
                    queue.add(curr.left);
                    queue.add(curr.right);
                }
            }
        }
        return true;
    }
    private static boolean isPalindrome(Queue<TreeNode> queue) {
        ArrayList<TreeNode> list = new ArrayList<TreeNode>(queue);
        int i = 0, j = list.size() - 1;
        while(i < j) {
            TreeNode left = list.get(i);
            TreeNode right = list.get(j);
            if(left != null || right != null) {
                if(left == null || right == null || left.val != right.val) {
                    return false;
                }
            }
            i++;
            j--;
        }
        return true;
    }
    public static void main(String[] args) {
        TreeNode n1 = new TreeNode(1);
        TreeNode n2 = new TreeNode(2);
        TreeNode n3 = new TreeNode(2);
        TreeNode n4 = new TreeNode(3);
        TreeNode n5 = new TreeNode(4);
        TreeNode n6 = new TreeNode(4);
        TreeNode n7 = new TreeNode(3);
        n1.left = n2; n1.right = n3;
        n2.left = n4; n2.right = n5;
        n3.left = n6; n3.right = n7;
        
        System.out.println(checkIfSymIterative(n1));
        
        TreeNode n8 = new TreeNode(1);
        TreeNode n9 = new TreeNode(2);
        TreeNode n10 = new TreeNode(2);
        TreeNode n11 = new TreeNode(3);
        TreeNode n12 = new TreeNode(3);
        n8.left = n9; n8.right = n10;
        n9.right = n11;
        n10.right = n12;
        
        System.out.println(checkIfSymIterative(n8));        
    }
}

Solution 1. Recursion

For two trees t1 and t2 to be mirror of each other, the following three conditions must be true 

1. their root node's value must be the same.

2. t1's left subtree must be mirror of t2's right subtree.

3. t1's right subtree must be mirror of t2's left subtree.

The base case is when t1 and t2 are both null, they are mirror of each other.

Solution 2. Iterative using level order traversal

There are 2 ways of doing this.

1. do a regular level order traversal from left to right at each level, then check if all nodes of each level are palindromic.

2. enqueue in the following order:

　 left child of left subtree -> right child of right subtree -> right child of left subtree -> left child of right subtree.

    always dequeue the first 2 nodes from the queue and compare if they are the same.