024-leetcode-树-对称二叉树

package tree;

import java.util.Deque;
import java.util.LinkedList;

/**
 * 对称二叉树
 * 给定一个二叉树，检查它是否是镜像对称的。
 *
 *  
 *
 * 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
 *
 *     1
 *    / \
 *   2   2
 *  / \ / \
 * 3  4 4  3
 *  
 *
 * 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
 *
 *     1
 *    / \
 *   2   2
 *    \   \
 *    3    3
 *  
 *
 * 进阶：
 *
 * 你可以运用递归和迭代两种方法解决这个问题吗？
 *
 * 作者：力扣 (LeetCode)
 * 链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/xn7ihv/
 * 来源：力扣（LeetCode）
 * 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
 *
 * */
public class IsSymmetric {

    private static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }

        TreeNode(int val) {
            this.val = val;
        }
    }
    
    public static void main(String[] args) {
        TreeNode node1 = new TreeNode(1);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(2);
        TreeNode node4 = new TreeNode(3);
        TreeNode node5 = new TreeNode(4);
        TreeNode node6 = new TreeNode(4);
        TreeNode node7 = new TreeNode(3);

        node1.left = node2;
        node1.right = node3;

        node2.left = node4;
        node2.right = node5;

        node3.left = node6;
        node3.right = node7;

        boolean isSymmetric = isSymmetric(node1);
        System.out.println("isSymmetric "+isSymmetric);
        boolean isSymmetricNew = isSymmetricNew(node1);
        System.out.println("isSymmetricNew "+isSymmetricNew);

    }

    private static boolean isSymmetric(TreeNode rootNode){
        if (rootNode==null){
            return true;
        }
        return isSymmetricHelper(rootNode.left, rootNode.right);
    }

    private static boolean isSymmetricHelper(TreeNode left, TreeNode right){
        if (left ==null && right ==null){ // 到了叶子节点 如果两个都为空，则表明是叶子节点，考虑只有一个节点的情况 都没有左右接节点，但是是对称二叉树
            return true;
        }
        if (left==null || right==null || (left.val!=right.val)){ // 考虑左边节点和右边节点的数值是否一致
            return false;
        }
        // 考虑下左右节点都又有子节点这种情况
        //         1
        //     2       2
        //  3   4    4    3
        //5 6 6 5   5 6  6 5  <--- 这一行和上面一行一样的 就不要再细致考虑，看明白意思一样即可，过程是一样考虑太多脑子容易乱 容易爆栈
        // 这时候观察:
        // 1. 发现左子树节点2的左子节点3和右子树节点2的右节点3相同  即 left.left==right.right
        // 2. 发现左子树节点2的右子节点4和右子树节点2的左节点4相同  即 left.right == right.left
        return isSymmetricHelper(left.left, right.right) && isSymmetricHelper(left.right, right.left);
    }


    // 上面的解法是递归写法
    // 非递归写法 就是利用for或者while循环来进行处理
    // 层序遍历 之前获取树的最大高度的时候，我们就用的是层序遍历 当时一开始push进去的是一个，这次因为是需要要进行获取到两个根节点来做比较(2 2) push进去两个
    private static boolean isSymmetricNew(TreeNode rootNode){
        if (rootNode==null){
            return true;
        }
        if (rootNode.left==null && rootNode.right==null){
            return true;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.push(rootNode.left);
        deque.push(rootNode.right);
        while (!deque.isEmpty()){
            TreeNode left = deque.pop(); TreeNode right = deque.pop();
            // 如果左节点和右节点都为空，可以认为符合条件，但是后面的判断和处理就不需要了，即不需要判断值相等，是否添加新的节点
            // 然后继续处理下一组左右子树的数据
            //         1
            //     2       2
            // nil  3    3  nil
            if (left==null && right ==null){
                continue;
            }
            if (left==null ^ right==null){
                return false;
            }
            if (left.val!=right.val){
                return false;
            }
            // 如果确定左节点和右节点相等，那么就可以继续添加新的节点进行判断
            deque.addLast(left.left);
            deque.addLast(right.right);
            deque.addLast(left.right);
            deque.addLast(right.left);
        }
        return true;
    }
}

输出结果：

isSymmetric true
isSymmetricNew true