二叉树镜像

101. Symmetric Tree

same tree

这道题目可以使用same tree的解法来做

判断两颗树是否相同，从根节点开始判断，然后两两比较两个树的左右孩子节点

public boolean isSameTree(TreeNode p, TreeNode q) {
    if(p==null && q==null){
        return true;
    }else if(p==null || q==null){
        return false;
    }
       //判断根节点
    if(p.val==q.val){
    //判断孩子节点
        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
    }else{
        return false;
    }
}

递归方法

与上面一题不同的是，这个树是同一个树上面判断，所以得创造两个树处理，根节点不用判断，从左右子树开始为根节点（在这里就类似判断两个树是否相同树的结构体）

代码

/**
 * Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
 *
 * For example, this binary tree [1,2,2,3,4,4,3] is symmetric:
 *
 *     1
 *    / \
 *   2   2
 *  / \ / \
 * 3  4 4  3
 * But the following [1,2,2,null,3,null,3] is not:
 *     1
 *    / \
 *   2   2
 *    \   \
 *    3    3
 *    //判断相同的镜像树
 */
public class SymmetricTree {
     //递归方法解决该问题
    public boolean isSymmetric(TreeNode root) {
    //如果不是为空的情况下，如何进行处理
        //求出镜像树
        if(root==null || (root.right==null && root.left==null)) {return true;}
       //重复判断
       // if(root.right==null) {return false;}
        //if(root.left==null){return false;}
        
        return helper(root.left,root.right);
    }
    //创造两个树的情况
    private boolean helper(TreeNode left, TreeNode right){
        if(left==null && right==null ){return true;}
        if(left==null) {return false;}
        if(right==null) {return false;}
        if(right.val!=left.val) {
            return false;
        }
        return helper(left.left,right.right) && helper(right.left,left.right);
    }
}

对上述代码进行优化

class Solution {
    public boolean isSymmetric(TreeNode root) {
    //如果不是为空的情况下，如何进行处理
        //求出镜像树
        return root==null || helper(root.left, root.right);
    }
    private boolean helper(TreeNode left, TreeNode right){
        if(left==null|| right==null) return left == right;
        if(right.val!=left.val) {
            return false;
        }
        return helper(left.left,right.right) && helper(right.left,left.right);
    }
}

递归的多种解法

判读左右的情况

private boolean recursiveIsSymmetric(TreeNode left, TreeNode right) {

        if (null == left && null == right) {
            return true;
        }
        if (null == left || null == right) {
            return false;
        }
        //
        boolean leftLeftRightRight = recursiveIsSymmetric(left.left, right.right);
        boolean leftRightRightLeft = recursiveIsSymmetric(left.right, right.left);
        if (leftLeftRightRight && leftRightRightLeft && left.val == right.val) {
            return true;
        }
        return false;
    }

非递归方法

使用stack

根节点不进入stack里面，其中左右节点入stack，每次都是从stack中弹出两个treeNode ，这两个节点是原本树中要检查的两个点， 比如

每一次都是潘敦啊两次节点的情况，代码书写习惯就是每次判断过程中是否有错误的情况出现，然后最后return true
是这种情况下，每次判断都是两个节点下的情况进行迭代处理，每次处理的是
** 两两处理**，查找对比过程中

求镜像树