《剑指Offer》Java刷题 NO.58 对称的二叉树(二叉树，递归，DFS&BFS)

《剑指Offer》Java刷题 NO.58 对称的二叉树(二叉树，递归，DFS&BFS)

传送门：《剑指Offer刷题总目录》

时间：2020-07-11
题目：
请实现一个函数，用来判断一棵二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

---

思路：
这个地方对称二叉树的意思就是沿着中线折叠起来能完全重合哈哈哈
方法一：递归
之前做过一道二叉树的镜像，就是把二叉树的左右子树一层一层的交换:NO.18 二叉树的镜像(二叉树镜像、递归)
这道题其实更简单，就是判断左右孩子，全为空返回true，其中一个为空返回false，都不为空再判断左右孩子的值是否相同，并且左孩子的左子树与右孩子的右子树&左孩子的右子树与右孩子的左子树是否相同
方法二：非递归
在评论区看到大神用DFS和BFS思想实现了非递归，思路其实一样，只不过DFS用栈来保存结点，所以运行的时候是从最深的地方向上判断的【但是并不是一路压栈直到叶节点再处理】
BFS用Queue来保存结点，所以确实是一层一层从左往右来判断的 【这道题用BFS比较舒服】
相同点： 每次保存两对结点：left.left&right.right left.right&right.left
每次pop出一对结点

• 如果全为null，continue
• 如果其中一个为null，或者两个结点的值不相等，直接返回false；
• 如果两个结点的值相等：就把上述两对结点保存

---

Java代码：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/**
 * @author LiMin
 * @Title: IsSymmetrical
 * @Description: 请实现一个函数，用来判断一棵二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
 * @date 2020/7/15  15:31
 */
public class IsSymmetrical {
    private static class TreeNode {
        int val = 0;
        TreeNode left = null;
        TreeNode right = null;

        TreeNode(int val) {
            this.val = val;
        }
    }

    public boolean isSymmetrical(TreeNode pRoot) {
        if (pRoot == null) {
            return true;
        }
        return judge(pRoot.left, pRoot.right);
    }

    public boolean judge(TreeNode left, TreeNode right) {
        if (left == null && right == null) {
            return true;
        }//left和right不全为null
        if (left == null || right == null) {
            return false;
        }//left和right全不为null
        return left.val == right.val && judge(left.left, right.right) && judge(left.right, right.left);
        //left.left和right.right；left.right和right.left分别对应比较
    }

    public static boolean isSymmetricalDFS(TreeNode pRoot) {
        if (pRoot == null) {
            return true;
        }
        Stack<TreeNode> tree = new Stack<>();
        tree.push(pRoot.left);
        tree.push(pRoot.right);
        while (!tree.empty()) {
            TreeNode left = tree.pop();
            TreeNode right = tree.pop();
            if (left == null && right == null) {
                //两个都为null就继续pop
                continue;
            }
            if (left == null || right == null || left.val != right.val) {
                //其中一个为null或者值不相等
                return false;
            }
            tree.push(left.left);
            tree.push(right.right);
          
            tree.push(left.right);
            tree.push(right.left);
     
        }
        return true;
    }

    public static boolean isSymmetricalBFS(TreeNode pRoot) {
        if (pRoot == null) {
            return true;
        }
        Queue<TreeNode> tree = new LinkedList<>();
        tree.offer(pRoot.left);
        tree.offer(pRoot.right);
        
        while (!tree.isEmpty()) {
            TreeNode left = tree.poll();
            TreeNode right = tree.poll();
            if (left == null && right == null) {
                //两个都为null就继续pop
                continue;
            }
            if (left == null || right == null || left.val != right.val) {
                //其中一个为null或者值不相等
                return false;
            }
            
            tree.offer(left.left);
            tree.offer(right.right);
           
            tree.offer(left.right);
            tree.offer(right.left);
           
        }
        return true;
    }
}