【剑指Offer系列】-28对称的二叉树(镜像、中序遍历、前置判断)

题目：

请实现一个函数，用来判断一棵二叉树是不是对称的。

思路：

• 中序遍历二叉树，midList1（必须使用中序遍历）
• 对二叉树进行镜像
• 中序遍历镜像后的二叉树，midList2
• 判断midList1.equals(midList2)

注意事项：

这种二叉树，midList1.equals(midList2)返回true，但是它不是对称二叉树。所以，上述思路需要加一个前置判断

• 从root节点开始，将所有的左子节点存入list1[1,2,2]
• 从root节点开始，将所有的右子节点存入list2[1,2]
• list1和list2如果元素个数不一样，则不是对称二叉树

public class IsSymmetry {
    public static void main(String[] args) {
        // [1,2,2,3,4,4,3]
        TreeNode n11 = new TreeNode(1);
        TreeNode n21 = new TreeNode(2);
        TreeNode n22 = new TreeNode(2);
        TreeNode n31 = new TreeNode(3);
        TreeNode n32 = new TreeNode(4);
        TreeNode n33 = new TreeNode(4);
        TreeNode n34 = new TreeNode(3);
        n11.left = n21; n11.right = n22;
        n21.left = n31; n21.right = n32;
        n22.left = n33; n22.right = n34;
        boolean res = isSymmetry(n11);
        System.out.println(res);
    }

    private static boolean isSymmetry(TreeNode root) {
        if (root == null) {
            return false;
        }
        if (root.left == null && root.right == null) {
            return true;
        }

		// 前置判断，上图中假的对称
        List<TreeNode> l1 = new ArrayList<>();
        TreeNode temp1 = root;
        while (temp1 != null) {
            l1.add(temp1);
            temp1 = temp1.left;
        }
        List<TreeNode> l2 = new ArrayList<>();
        TreeNode temp2 = root;
        while (temp2 != null) {
            l2.add(temp2);
            temp2 = temp2.right;
        }
        if (l1.size() != l2.size()) {
            return false;
        }
		
		// 正常判断
        List<Integer> midList = new ArrayList<>();
        midTraverse(midList , root);

        // 镜像
        mirrorTree(root);
        List<Integer> mirredMidList = new ArrayList<>();
        midTraverse(mirredMidList , root);
        return mirredMidList.equals(midList );
    }

    private static void mirrorTree(TreeNode root) {
        if (root == null) {
            return;
        }
        recursion(root, root.left, root.right);
    }

    private static void recursion(TreeNode root, TreeNode leftNode, TreeNode rightNode) {
        if (leftNode == null && rightNode == null) {
            return;
        }
        root.left = rightNode;
        root.right = leftNode;
        if (leftNode != null) {
            recursion(leftNode, leftNode.left, leftNode.right);
        }
        if (rightNode != null) {
            recursion(rightNode, rightNode.left, rightNode.right);
        }
    }
    
    private static void midTraverse(List<Integer> preList, TreeNode root) {
        if (root == null) {
            return;
        }
        midTraverse(preList, root.left);
        preList.add(root.val);
        midTraverse(preList, root.right);
    }
}