2.＜tag-二叉树和翻转, 对称专题＞-lt.226. 翻转二叉树(同剑指 27 )+ lt.101. 对称二叉树(同剑指 28) + lt.100. 相同的树 + lt.572. 另一棵树的子树

lt.226. 翻转二叉树

[案例需求]

• 权威题解

[思路分析一, 递归实现]

我们在做二叉树题目时候，第一想到的应该是用 递归 来解决。
仔细看下题目的 输入 和 输出，输出的左右子树的位置跟输入正好是相反的，于是我们可以递归的交换左右子树来完成这道题。

[代码实现]

/**
 * 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 {
 //1. 递归函数: 反转每个root的子树,  参数: root是当前节点, 这个节点被看做是所在子树的根节点
    // 返回值: 是被看做是根节点的当前节点
	public TreeNode invertTree(TreeNode root) {
		//2. 递归结束条件
		if(root==null) {
			return root;
		}
		//3. 单层递归逻辑
		//因为是先前序遍历，所以先进行交换左右孩子节点，然后反转左子树，反转右子树。
		//下面三句是将当前节点的左右子树交换
		TreeNode tmp = root.right;
		root.right = root.left;
		root.left = tmp;
		//递归交换当前节点的 左子树
		invertTree(root.left);
		//递归交换当前节点的 右子树
		invertTree(root.right);
		//函数返回时就表示当前这个节点，以及它的左右子树
		//都已经交换完了
		return root;
	}
}

[思路分析二, 迭代实现]

[代码实现]

/**
 * 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) {
         //BFS
        Queue<TreeNode> queue = new ArrayDeque<>();
        if(root == null)return root;
        queue.add(root);

        TreeNode res = root;
        while(!queue.isEmpty()){
            root = queue.poll();

            TreeNode temp = root.left;
            root.left = root.right;
            root.right = temp;

            if(root.left != null)queue.add(root.left);
            if(root.right != null)queue.add(root.right);
        }

        return res;
    }
}

lt.101. 对称二叉树

[案例需求]

[思路分析一, 递归实现]

[代码实现]

/**
 * 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) {
        if(root == null)return true;

        return isSym(root.left, root.right);
    }

    //确定递归函数的参数和返回值, 
    // 参数是树的左右孩子结点, 递归过程就是比较root左右孩子结点的左右子树
    public boolean isSym(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 outSide = isSym(left.left, right.right);
        boolean inSide = isSym(left.right, right.left);

        return outSide && inSide;
    }
}

[思路分析二, 迭代法]

• 详细题解

[代码实现]

/**
 * 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) {
        if(root == null)return true;
        if(root.left == null && root.right == null)return true;

        // linkedList!!
        Queue<TreeNode> queue = new LinkedList<>();
        //将根节点的左右孩子放到队列中
        queue.add(root.left);
        queue.add(root.right);

        while(!queue.isEmpty()){
        	//从队列中取出两个节点，再比较这两个节点
            TreeNode left = queue.poll();
            TreeNode right = queue.poll();

            如果两个节点都为空就继续循环，两者有一个为空就返回false
            if(left == null && right == null)continue;
            if(left == null || right == null)return false;
            if(left.val != right.val)return false;

            //外侧比较: 添加左孩子的左孩子结点, 添加右孩子的右孩子结点
            queue.add(left.left);
            queue.add(right.right);
            //内侧比较: 添加左孩子的右孩子结点, 添加右孩子的左孩子结点
            queue.add(left.right);
            queue.add(right.left);
        }
        return true;
    }
}

lt.100. 相同的树

[案例需求]

[思路分析一, 递归]

[代码实现]

/**
 * 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;
        if(p.val != q.val)return false;

        //单层递归逻辑, 返回值
        boolean leftSide = isSameTree(p.left, q.left);
        boolean rightSide = isSameTree(p.right, q.right);

        return leftSide && rightSide;
    }
}

[思路分析二, 迭代]

[代码实现]

/**
 * 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.add(p);
        queue.add(q);

        while(!queue.isEmpty()){
            TreeNode left = queue.poll();
            TreeNode right = queue.poll();

            if(left == null && right == null)continue;

            if((left == null || right == null) || left.val != right .val)return false;
            //左外侧与右内测比较: 添加左子树的左孩子和右子树的右孩子
            queue.add(left.left);
            queue.add(right.left);
            //左内侧与右外侧比较: 添加左子树的右孩子和右子树的左孩子
            queue.add(left.right);
            queue.add(right.right);
        }
        return true;    
    }
}

lt.572. 另一棵树的子树

[案例需求]

[思路分析一, 递归]

• 战略撤退, 过段时间再补(我特么爆哭这简单题)
• 我来鸟; 详细题解

[代码实现]

/**
 * 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 isSym(root.left, root.right);
    }
    //1. 递归函数, 要比较的是两棵子树, 所以参数需要两个当前结点(指代左子树 右子树)
    //返回值是对称与否, 
    public boolean isSym(TreeNode L, TreeNode R){
        //2. 递归结束条件
        // L 为空, R不为空.
        // L不为空, R为空;
        // L和R不相等;
        //L和R均为空
        if(L == null && R == null){
            return true;
        }else if(L == null || R == null){
            return false;
        }else if(L.val != R.val){
            return false;
        }

        //3. 单层递归逻辑
        boolean outside = isSym(L.left, R.right);
        boolean inside = isSym(L.right, R.left);

        return outside && inside;
    }
}