代码随想录第十五天

内容：

1. 二叉树的层序遍历(102)
2. 翻转二叉树(226)
3. 对称二叉树(101)

1. 二叉树的层序遍历

难度：🔥🔥

建议：层序遍历并不难，学会后可以一口气刷十道题目

1.1 思路分析

我们通过队列的方式，实现二叉树的层序遍历。

我们先将根节点加入到队列中，用size来记录每一层的节点数目，在while循环中将它们的左右子孩子全部加入到队列中，继续遍历直到队列为空。

如图：

1.2 代码实现

BFS–迭代方式–借助队列

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        //用于存放结果集
        List<List<Integer>> result = new ArrayList<>();

        //LinkedList实现了双端队列(deque)接口，而deque继承于queue
        Queue<TreeNode> queue = new LinkedList<>();
        if (root == null) {
            return result;
        }
        //offer(E e)操作是专为容量受限的队列实现而设计的
        queue.offer(root);
        while (!queue.isEmpty()) {
            //size记录该层的节点数目
            int size = queue.size();
            //存放每一层的集合，每次循环结束加到结果集
            List<Integer> list = new ArrayList<>();
            while (size-- > 0) {
                //每次将该节点poll()出队列时都去判断左右节点是否为空，不为空则加入队列尾部
                TreeNode node = queue.poll();
                list.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }

            }
            result.add(list);
        }
        return result;
    }
}

1.3 注意事项

1.4 收获总结

学会二叉树的层序遍历我们可以做下面十道题目，使用层序遍历可以很轻松解决这些问题

• 102. 二叉树的层序遍历
• 107. 二叉树的层序遍历 II
• 199. 二叉树的右视图
• 637. 二叉树的层平均值
• 429. N 叉树的层序遍历
• 515. 在每个树行中找最大值
• 116. 填充每个节点的下一个右侧节点指针
• 117. 填充每个节点的下一个右侧节点指针 II
• 104. 二叉树的最大深度
• 111. 二叉树的最小深度

---

2. 翻转二叉树

难度：🔥🔥

建议：优先掌握递归

2.1 思路分析

使用前序或者后序遍历来解决这道问题

如图：

2.2 代码实现

dfs递归

class Solution {
    public TreeNode invertTree(TreeNode root) {

        if (root == null) {//递归结束的条件
            return root;
        }
        
        swapNode(root);
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
	//用于交换节点的左右孩子
  private void swapNode(TreeNode root){
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

bfs层序遍历

class Solution {
    public TreeNode invertTree(TreeNode root) {

        //bfs层序遍历
        Queue<TreeNode> queue = new LinkedList<>();
        if (root == null) {
            return root;
        }
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size-- > 0) {
                TreeNode node = queue.poll();
                swapNode(node);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return root;
    }
    private void swapNode(TreeNode root){
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

2.3 注意事项

2.4 收获总结

---

3.对称二叉树

难度：🔥🔥

建议：优先掌握递归

3.1 思路分析

这颗二叉树是否是对称二叉树，就看根节点的左右子树是否可以相互翻转。

在遍历的过程中比较内侧与外侧节点是否相同。

如图：

3.2 代码实现

class Solution {
    public boolean isSymmetric(TreeNode root) {

        return isSame(root.left,root.right);
    }
    private boolean isSame(TreeNode left,TreeNode right){
        if(left != null && right == null) return false;
        else if(left == null && right != null) return  false;
        else if(left == null && right == null) return true;
        else if(left.val != right.val) return false;
        //比较外部和内部节点是否相同
        boolean outSide = isSame(left.left,right.right);
        boolean inSide = isSame(left.right,right.left);
        return outSide && inSide;
    }
}

3.3 注意事项

3.4 收获总结