代码随想录算法训练营第十五天| LeetCode102.层序遍历、LeetCode226.翻转二叉树、LeetCode101.对称二叉树2

#LeetCode102. Binary Tree Level Order Traversal

#LeetCode 10. 视频讲解：讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历_哔哩哔哩_bilibili

本题是使用层序遍历算法，二叉树有多少层，List<List<Integer>> result 就有多少个元素，result 里每一个元素又是一个List<Integer> 形式。

使用队列来完成，首先放入根节点，然后放入根节点的左右节点，需要一个额外的变量来记录放入了多少个元素（以每一层为单位），方便在输出的时候知道输出几个元素。每次输出的元素都需要顺序放入该节点的左右子节点（如果非空）。当队列为空时代表已经遍历完成。

队列实现方法：

/**
 * 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 List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> result = new ArrayList<>();
        int size = 0;
        if (root == null) {
            return result;
        }
        if (root != null) {
            queue.add(root);
        }
        while (!queue.isEmpty()) {
            size = queue.size();
            List<Integer> mid = new ArrayList<Integer>();
            while (size > 0) {
                TreeNode node = queue.peek();
                mid.add(node.val);
                queue.poll();
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
                size--;
            }
            result.add(mid);
        }
        return result;
    }
}

#LeetCode226. Invert Binary Tree

 #LeetCode 226. 视频讲解：听说一位巨佬面Google被拒了，因为没写出翻转二叉树 | LeetCode：226.翻转二叉树_哔哩哔哩_bilibili

首先明确当用到递归遍历时需要考虑的步骤： 

1. 确定递归函数的参数和返回值（返回值为新二叉树的根节点）

2. 确定终止条件（root 为null ，这里的不只是空根节点，还有是遍历过的每一个节点）

3. 确定单层逻辑、递归逻辑（这里是前序遍历或者后序遍历更合适）

本题需要交换每个节点的左右孩子，新建一个函数swap 来交换节点，然后使用递归调用。以下代码顺序为中左右，为前序遍历。如果使用后序遍历，只需要更改节点之间的顺序。

递归方法（前序遍历）方法：

/**
 * 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 root;
        }
        swap(root);
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
    public void swap(TreeNode root) {
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

#LeetCode101. Symmetric Tree

#LeetCode 101. 视频讲解：

新学期要从学习二叉树开始！ | LeetCode：101. 对称二叉树_哔哩哔哩_bilibili

首先明确当用到递归遍历时需要考虑的步骤： 

1. 确定递归函数的参数和返回值（返回值为boolean 类型的true 和false）

2. 确定终止条件（存在不相等的情况时）

3. 确定单层逻辑、递归逻辑（因为是收集左右孩子信息返回上一层节点，所以后序遍历更合适）

不相等情况：

1. 左节点为空，右节点不为空

2. 左节点不为空，右节点为空 --> false（不对称）

3.  左右节点都为空  --> true（对称）

4. 左右节点不为空，但值不相等 --> false（不对称）

 递归调用方法：

/**
 * 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);
    }
    public boolean compare(TreeNode left, TreeNode right) {
        if ((left != null && right == null) || (left == null && right != null)) {
            return false;
        }
        else if (left == null && right == null){
            return true;
        }
        else {
            if (left.val != right.val) {
                return false;
            }
            boolean compareOutside = compare(left.left, right.right);
            boolean compareInside = compare(left.right, right.left);
            return compareOutside && compareInside;
        }
    }
}