[树] 101. 对称二叉树（前序遍历 + 方法优化）

第101. 对称二叉树

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

分类：树（二叉树）、前序遍历（递归、迭代）、算法优化

思路1：左右同步dfs(前序遍历 - 递归实现，遍历2次)

分别按 根->左->右 和 根->右->左 的方式使用深度优先遍历，一旦出现遍历过程中其中一个节点为空，另一个不为空，或两个节点val不相等，就返回false。
遍历到最后都没有中断，则说明二叉树是对称的，返回true。

实现代码实质上就是前序遍历，但一个是先遍历左子树，后遍历右子树；另一个是先遍历右子树，后遍历左子树。

实现代码

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return dfs(root, root);
    }
    //左右同步dfs，即前序遍历
    public boolean dfs(TreeNode root1, TreeNode root2){
        if(root1 == null && root2 == null) return true;//两种遍历都遇到空节点
        if(root1 == null || root2 == null) return false;//只有一种遍历遇到空节点
        if(root1.val != root2.val) return false;//两个遍历节点val不相等时
        return dfs(root1.left, root2.right) && dfs(root1.right, root2.left);//一个先进入左子树，一个先进入右子树
    }
}

思路1 优化：只遍历一次

思路1的方法会导致整体上遍历了这棵树两次， 根->左->右 和 根->右->左 都分别完整地遍历了一次二叉树，但实际上只需要比较到两个遍历节点相遇时即可停止，因为后续的比较结果和前面是完全一致的。

所以递归出口可以修改为：

if(root1 == root2) return true;

两个节点相遇时，说明遇到二叉树对称轴上的节点，可以直接返回，不需要再继续遍历下去了。

同时遍历的起点也修改为root的左右孩子：root.left和root.right，避免做了上面的修改后，从root开始比较时一进入递归函数就立即退出:

    dfs(root.left, root.right);

实现代码

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null) return true;
        else return dfs(root.left, root.right);
    }
    //左右同步dfs，即前序遍历
    public boolean dfs(TreeNode root1, TreeNode root2){
        if(root1 == root2) return true;//两个遍历节点相遇时，直接返回true，中断遍历过程
        if(root1 == null || root2 == null) return false;//只有一种遍历遇到空节点
        if(root1.val != root2.val) return false;//两个遍历节点val不相等时
        return dfs(root1.left, root2.right) && dfs(root1.right, root2.left);//一个先进入左子树，一个先进入右子树
    }
}

思路2：左右同步dfs(前序遍历 - 迭代实现，遍历1次)

一趟遍历同时从左右子树开始。前序遍历的迭代实现，所以使用两个栈分别用于根->左->右和根->右->左的前序遍历。

实现代码的框架和 单趟前序遍历的迭代 实现基本相同，修改的细节有：

1、两趟前序遍历待入栈节点的入栈操作
入栈的遍历过程中暂时处理不到的点，所以存入栈中，根据两趟遍历的特点，根->左->右遍历入栈的是右孩子，根->右->左入栈的是左孩子：

    stack1.push(root1.right);
    stack2.push(root2.left);

注意在待处理节点入栈之前要先做比较:因为这两个待入栈节点就是对称节点，只有同时为空，或同时不为空且val相等才能入栈

• 如果两个待入栈节点其中一个为空，其中一个不为空，则返回false；
• 如果都不为空，则要在入栈前判断val是否相等，因为这两个节点在树上就是对称节点；
  • 如果val不相等，也要立即返回false；
  • 如果val相等，两节点才入栈；
    //如果两趟遍历对应的待入栈孩子节点(根->左->右存右孩子，根->右->左存左孩子)其中一个为空，则返回false.

    if(root1.right == null && root2.left != null || (root1.right != null && root2.left == null)) return false;
    //都不为空时
    if(root1.right != null && root2.left != null){
        //如果val不相等则直接返回false，因为这两个节点就是对称节点
        if(root1.right.val != root2.left.val) return false;
        //val相等才入栈
        stack1.push(root1.right);
        stack2.push(root2.left);
    }

2、在退出内部循环while(root1 != null && root2 != null)之后，弹出栈顶之前，两个当前节点可能一个为空，一个不为空，此时要返回false：

  //如果其中一个节点为空，另一个节点不为空,则直接返回false
  if((root1 == null && root2 != null) || (root1 != null && root2 == null)) return false;

例如：
       2
   3       3
 4   5  5
根左右遍历到4，根右左遍历到3.right==null时，会退出内层循环，此时这两个节点是不对称的，要返回false。

优化部分和思路1的优化相同，在遇到root1==root2时，说明两趟遍历相遇，可以不用再继续遍历，立即退出当前遍历过程。

实现代码

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null) return true;
        else return dfs(root.left, root.right);//从根节点的左右孩子开始
    }
    //左右同步dfs，即前序遍历，迭代实现
    public boolean dfs(TreeNode root1, TreeNode root2){
        //左右子树各自根节点的预处理
        if(root1 == root2) return true;//两个遍历节点相遇时，直接返回true，中断遍历过程（将整体遍历计算量减少一半）
        if(root1 == null || root2 == null) return false;//只有其中一趟遍历遇到空节点，另一个为非空，则返回false
        if(root1.val != root2.val) return false;//两个遍历节点val不相等时    

        Stack<TreeNode> stack1 = new Stack<>();//用于根->左->右
        Stack<TreeNode> stack2 = new Stack<>();//用于根->右->左

        while((!stack1.isEmpty() && !stack2.isEmpty()) || (root1 != null && root2 != null)){
            //优化
            if(root1 == root2) return true;//两个遍历节点相遇时，直接返回true，中断遍历过程（将整体遍历计算量减少一半）
            if(root1 == null || root2 == null) return false;//只有其中一趟遍历遇到空节点，另一个为非空，则返回false

            //其中一个节点或两个节点都为空时就退出循环
            while(root1 != null && root2 != null){
                //两个节点都不为空，则比较val
                if(root1.val != root2.val) return false;
                
                //如果两趟遍历对应的暂存孩子节点(根->左->右存右孩子，根->右->左存左孩子)其中一个为空，则返回false
                if(root1.right == null && root2.left != null || (root1.right != null && root2.left == null)) return false;
                //都不为空时
                if(root1.right != null && root2.left != null){
                    //如果val不相等则直接返回false，因为这两个节点就是对称节点
                    if(root1.right.val != root2.left.val) return false;
                    //val相等才入栈
                    stack1.push(root1.right);
                    stack2.push(root2.left);
                }
                root1 = root1.left;
                root2 = root2.right;
            }
            //如果其中一个节点为空，另一个节点不为空,则直接返回false
            if((root1 == null && root2 != null) || (root1 != null && root2 == null)) return false;
            //从栈中弹出之前暂存的节点
            if(!stack1.isEmpty() && !stack2.isEmpty()){
                root1 = stack1.pop();
                root2 = stack2.pop();
            }
        }
        return true;
    }
}