101.Symmetric Tree

题目链接：https://leetcode.com/problems/symmetric-tree/description/

题目大意：给出一个二叉树，判断其是否是对称的，例子如下

法一：用常规层序遍历一直WA，某一天突然开窍发现bug，改了之后提交ac了，这个bug其实就是怎么去记录当前层的最后一个结点，不能直接用结点指针进行标记，因为有可能出现null的情况，也不能用每层固定的结点个数也就是2^depth来进行判断是否是一层的最后一个结点，因为前面可能有很多个null，而并不是每个null都会进入队列。这里采用的办法是利用queue.size()来记录每层进队列的结点个数，然后利用cnt--操作来判断当前层是否遍历完。虽然时间长点，但毕竟自己的心血，代码如下（耗时5ms）：

    public static boolean isSymmetric(TreeNode root) {
        if(root == null) {
            return true;
        }
        boolean flag = true;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int cnt = 1;
        List<TreeNode> listNode = new ArrayList<TreeNode>();
        while(!queue.isEmpty()) {
            TreeNode node = queue.poll();
            cnt--;
            listNode.add(node);
            if(node != null) {
                queue.offer(node.left);
                queue.offer(node.right);
            }
            if(cnt == 0) {
                cnt = queue.size();
                int length = listNode.size();
                for(int i = 0; i < length / 2; i++) {
                    if((listNode.get(i) == null && listNode.get(length - 1 - i) != null) ||
                        (listNode.get(i) != null && listNode.get(length - 1 - i) == null)) {
                        flag = false;
                        break;
                    }
                    else if(listNode.get(i) != null && listNode.get(length - 1 - i) != null) {
                        if(listNode.get(i).val != listNode.get(length - 1 - i).val) {
                            flag = false;
                            break;
                        }
                    }
                }
                if(flag == false) {
                    return flag;
                }
                listNode.clear();
            }
        }
        return flag;
    }

法二（借鉴）：看完题解后，利用层序遍历的变种，每次进队时同时压入左右孩子，注意压入的顺序，代码如下（耗时2ms）：

    public static boolean isSymmetric(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        queue.offer(root);
        boolean flag = true;
        while(!queue.isEmpty()) {
            TreeNode nodeLeft = queue.poll();
            TreeNode nodeRight = queue.poll();
            
            if((nodeLeft != null && nodeRight == null) || (nodeLeft == null && nodeRight != null)) {
                return false;
            }
            else if(nodeLeft != null && nodeRight != null) {
                if(nodeLeft.val != nodeRight.val) {
                    return false;
                }
                else {
                    queue.offer(nodeLeft.left);
                    queue.offer(nodeRight.right);
                    
                    queue.offer(nodeLeft.right);
                    queue.offer(nodeRight.left);
                }
            }
        }
        return flag;
    }

法三（借鉴）：利用双端队列来做，思想与法二类似，每次同时压入左右孩子，只是这里用到了java中的双端队列类，代码如下（耗时3ms）：

    public static boolean isSymmetric(TreeNode root) {
        Deque<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offerFirst(root);
        queue.offerLast(root);
        boolean flag = true;
        while(!queue.isEmpty()) {
            TreeNode nodeLeft = queue.pollFirst();
            TreeNode nodeRight = queue.pollLast();
            
            if((nodeLeft != null && nodeRight == null) || (nodeLeft == null && nodeRight != null)) {
                return false;
            }
            else if(nodeLeft != null && nodeRight != null) {
                if(nodeLeft.val != nodeRight.val) {
                    return false;
                }
                else {
                    queue.offerFirst(nodeLeft.left);
                    queue.offerFirst(nodeLeft.right);
                    
                    queue.offerLast(nodeRight.right);
                    queue.offerLast(nodeRight.left);
                }
            }
        }
        return flag;
    }

法四（借鉴）：这个比较难，利用递归左右子树同时判断，代码如下（耗时0ms）：

    public static boolean isSymmetric(TreeNode root) {
        if(root == null) {
            return true;
        }
        return isSymmetric2(root, root);
    }
    public static boolean isSymmetric2(TreeNode root1, TreeNode root2) {
        if(root1 == null && root2 == null) {
            return true;
        }
        else if(root1 == null || root2 == null) {
            return false;
        }
        else {
            if(root1.val != root2.val) {
                return false;
            }
            else {
                return isSymmetric2(root1.left, root2.right) && isSymmetric2(root1.right, root2.left);
            }
        }
    }