二叉树的翻转和对称

1.翻转二叉树

翻转二叉树

思路：迭代，可以继续套用模板，只需要一个翻转操作。

模板

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    /*
    * 层序遍历
    */
    public TreeNode invertTree(TreeNode root) {
        Queue<TreeNode> queue =new LinkedList<>();
        if(root==null) return null;
        
        queue.offer(root);//根节点入队

        while(!queue.isEmpty()){
            int len = queue.size();

            for(int i=0;i<len;i++){
                TreeNode temp=queue.poll();//取出当前根节点
                swapChild(temp);//交换根节点的左右子节点
                
                //继续收集下一层的节点
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);
            }
        }
        return root;
    }


    //交换根节点的左右子节点
    private void swapChild(TreeNode root){
        TreeNode temp = root.left;
        root.left=root.right;
        root.right=temp;
    }
}

递归，我们只能使用前序遍历或者后序遍历，中序遍历不行，因为先左孩子交换孩子，再根交换孩子（做完后，右孩子已经变成原来的左孩子）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    /*
    * 前序遍历
    */
    public TreeNode invertTree(TreeNode root) {
        if(root==null) return null;
        swapChild(root);
        invertTree(root.left);
        invertTree(root.right);

        return root;
    }


    //交换根节点的左右子节点
    private void swapChild(TreeNode root){
        TreeNode temp = root.left;
        root.left=root.right;
        root.right=temp;
    }
}

2.对称二叉树

对称二叉树

1.先将根节点的左右孩子入队
2.比较左右孩子是否相等，若相等，则以此入队左孩子的左子节点，右孩子的右子节点；左孩子的右子节点，右孩子的左子节点。若不等，则返回false。若均为空，说明已经遍历完成，则退出（continue）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();//存放节点
        
        queue.offer(root.left);
        queue.offer(root.right);

        while(!queue.isEmpty()){
            TreeNode Lnode = queue.poll();
            TreeNode Rnode = queue.poll();
            if(Lnode==null&&Rnode==null) continue;
            if(Lnode==null&&Rnode!=null) return false;
            if(Lnode!=null&&Rnode==null) return false;
            if(Lnode.val!=Rnode.val) return false;
            // 两个节点值相等
            queue.offer(Lnode.left);  //外层
            queue.offer(Rnode.right);//外层

            queue.offer(Lnode.right);//内层
            queue.offer(Rnode.left);//内层
        }
        return true;//当不满足循环时，返回true

    }
}

递归，思路基本一致

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        return compare(root.left,root.right);
    }

    private boolean compare(TreeNode left,TreeNode right){
        /*
        * 终止递归的条件
        */
        if(left!=null&&right==null) return false;
        if(left==null&&right!=null) return false;
        if(left==null&&right==null) return true;
        if(left.val!=right.val) return false;
        
        //这是当前节点值相同的情况下（即单层逻辑）
        //比较外侧
        boolean compareOut = compare(left.left,right.right);
        //比较内侧
        boolean compareIn = compare(left.right,right.left);
        return compareOut&&compareIn;
    }
}

3.相同的树

相同的树

思路：1.需要处理根节点是否为空
2.若不为空，根节点入队
3.节点出队，比较是否为空和值是否相等。若值相等，两个树的节点入队

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        //先判断根节点是否为空
        if(p==null&&q==null) return true;
        if(p==null||q==null) return false;
        //根节点不为空
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(p);
        queue.offer(q);

        while(!queue.isEmpty()){
            //注意取出结点，否则造成死循环
            TreeNode Lnode = queue.poll();//取出根节点
            TreeNode Rnode = queue.poll();

            if(Lnode==null&&Rnode!=null) return false;
            if(Lnode!=null&&Rnode==null) return false;
            if(Lnode==null&&Rnode==null) continue;
            if(Lnode.val!=Rnode.val) return false;

            //节点不为空，且值相等
            queue.offer(Lnode.left);
            queue.offer(Rnode.left);
            queue.offer(Lnode.right);
            queue.offer(Rnode.right);
        }
        return true;
    }
}

4.另一棵树的子树

一棵树的子树

双重递归，思路基本和上述题相同

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        
         if(root==null &&subRoot ==null) return true;
         if(root==null||subRoot==null) return false;
         
         //根节点不为空
         Queue<TreeNode> queue = new LinkedList<>();
         queue.offer(root); //根节点入队
         while(!queue.isEmpty()){
            TreeNode temp = queue.poll();//取出根节点

            if(isSame(temp,subRoot)) return true;
            //如果是false，继续遍历
            if(temp.left!=null) queue.add(temp.left);
            
            if(temp.right!=null) queue.add(temp.right);
         }
         return false;
                 
    }

    public boolean isSame(TreeNode node1,TreeNode node2){
        if(node1==null&&node2==null) return true;
        if(node1==null||node2==null||node1.val!=node2.val) return false;
        //当前节点不为空且值相等,继续遍历
        return isSame(node1.left,node2.left)&&isSame(node1.right,node2.right);
    }
}