101 leetcode 对称二叉树

题意：
给定一个二叉树，检查它是否是镜像对称的。
解法一：
核心思想，中序和先序（后序）组合，可以唯一确定一颗二叉树。有了这个思路，既然镜像对称，那么从左往右和从右往左得到的序列应该是一样的。因为树中的元素没有限制，可以存在相同元素，所以需要添加一个条件，把有兄弟的那些空节点用null表示。这样保证了一颗二叉树一定是满二叉树，虽然一些节点是null。

class Solution {
    public boolean isSymmetric(TreeNode root) {
        seq1 = new ArrayList<>();
        seq2 = new ArrayList<>();
        inOrder1(null,root);
        inOrder2(null,root);
        if(!seq1.equals(seq2)) return false;
        seq1 = new ArrayList<>();
        seq2 = new ArrayList<>();
        preOrder1(null,root);
        preOrder2(null,root);
        return seq1.equals(seq2);
    }

    List<Integer> seq1, seq2;

    private void inOrder1(TreeNode brother, TreeNode node) {
        if (node == null) {
            if(brother != null) seq1.add(null);
            return;
        }
        inOrder1(node.right,node.left);
        seq1.add(node.val);
        inOrder1(node.left,node.right);
    }

    private void inOrder2(TreeNode brother, TreeNode node) {
        if (node == null) {
            if(brother != null) seq2.add(null);
            return;
        }
        inOrder2(node.left,node.right);
        seq2.add(node.val);
        inOrder2(node.right,node.left);
    }

    private void preOrder1(TreeNode brother, TreeNode node) {
        if (node == null) {
            if(brother != null) seq1.add(null);
            return;
        }
        seq1.add(node.val);
        preOrder1(node.right,node.left);
        preOrder1(node.left,node.right);
    }

    private void preOrder2(TreeNode brother, TreeNode node) {
        if (node == null) {
            if(brother != null) seq2.add(null);
            return;
        }
        seq2.add(node.val);
        preOrder2(node.left,node.right);
        preOrder2(node.right,node.left);
    }

}

解法二：
做完以后发现效率很没有优势，所以继续寻找更简单的方法。
一颗二叉树，如果是镜像二叉树，那么它需要满足以下条件：

1. 空树
2. 单个节点的树
3. 左子树和右子树对称，且左子树和右子树都是镜像二叉树。

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return isSymmetric(root, root);
    }

    private boolean isSymmetric(TreeNode left, TreeNode right) {
        if (left == null && right == null) { // 都是空，肯定是镜像
            return true;
        }
        if (left == null || right == null) { // 有一个是空，肯定不是镜像
            return false;
        }
        // 下面都是非空子树
        if (left.val == right.val) {
            return isSymmetric(left.left, right.right) && isSymmetric(left.right, right.left);
        }
        return false;
    }
}

解法三：
解法二的时间已经比较给力了，内存消耗只超过20%用户，大概是因为递归使用了栈吧，下面试试迭代的方法。
其中一个方法就是用BFS做一波层序遍历，每一层都是对称。

class Node {
    TreeNode node;
    int level;

    public Node(TreeNode node, int level) {
        this.node = node;
        this.level = level;
    }
}

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null || root.left == null && root.right == null) {
            return true;
        }
        Queue<Node> q = new ArrayDeque<>();
        boolean hasNotEmpty = true;
        q.offer(new Node(root.left,1));
        q.offer(new Node(root.right,1));
        List<Integer> levelList = null;
        int prevLevel = 0;
        while(!q.isEmpty()) {
            Node n = q.poll();
            TreeNode left = null, right = null;
            if(n.level != prevLevel) {
                if(!hasNotEmpty) break;
                System.out.println(levelList);
                hasNotEmpty = false;
                if(levelList != null) {
                    for(int i = 0, len = levelList.size(); i < len/2;i++) {
                        if(!Objects.equals(levelList.get(i),levelList.get(len - 1 - i))) {
                            return false;
                        }
                    }
                }
                levelList = new ArrayList<>();
                prevLevel = n.level;
            }
            if(n.node != null) {
                left = n.node.left;
                right = n.node.right;
                hasNotEmpty = true;
                levelList.add(n.node.val);
            } else {
                levelList.add(null);
            }
            q.offer(new Node(left,n.level+1));
            q.offer(new Node(right,n.level+1));
        }
        return true;
    }

}

内存直接爆炸。因为存了太多的null节点。

方法四：
用队列实现迭代版的方法二。
java的队列比较特别，ArrayDeque不允许插入null，因为null用来表示队列中不再有值。所以用LinkedList可以解决这个问题。不过Queue接口也不建议插入null值，以后多注意。

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null || root.left == null && root.right == null) {
            return true;
        }
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        q.offer(root);
        while(!q.isEmpty()) {
            TreeNode left = q.poll();
            TreeNode right = q.poll();
            if(left == null && right == null) continue;
            if(left != null && right != null) {
                if(left.val != right.val) return false;
                q.offer(left.left);
                q.offer(right.right);
                q.offer(left.right);
                q.offer(right.left);
            } else {
                return false;
            }
        }
        return true;
    }

}