day15 | 102. 二叉树的层序遍历、226. 翻转二叉树、101. 对称二叉树

奋进的叨叨

已于 2023-04-02 11:35:01 修改

阅读量112

点赞数

文章标签：算法 leetcode 数据结构

于 2023-04-01 20:18:21 首次发布

本文链接：https://blog.csdn.net/weixin_40718971/article/details/129902228

版权

文章介绍了如何进行二叉树的层序遍历，提供了递归和迭代两种解法，并详细解释了每种方法的思路和代码实现。此外，还讨论了翻转二叉树和判断对称二叉树的问题，同样给出了递归解决方案。

摘要由CSDN通过智能技术生成

102. 二叉树的层序遍历

题目

给你二叉树的根节点 root ，返回其节点值的层序遍历。（即逐层地，从左到右访问所有节点）。

在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

思路

解法一：递归

递解决此问题，三大板斧：最小问题；边界值；入参、出参；
- 最小问题：讲一个节点放入一个集合，一层一个集合，将元素放入集合即可
- 边界值：元素为null，就不用放了
- 入参：节点，层级深度，出参：迭代过程中不会使用计算元素，无需返回

代码实现

private List<List<Integer>> result = new ArrayList<>();


    /**
     * @param root
     * @param deep
     * @return
     */
    public void levelOrder_01(TreeNode root,int deep){
        if(root == null){
            return ;
        }
        deep++;
        while (result.size() < deep ){
            List<Integer> leaveList = new ArrayList();
            result.add(leaveList);
        }
        result.get(deep-1).add(root.getValue());
        levelOrder_01(root.getLeft(), deep+1);
        levelOrder_01(root.getRight(), deep+1);
    }

解法一：迭代

使用队列解决

一层入队，记录队列长度
一层出队，一层出完之后，二层入队
循环上述步骤即可

代码实现

 public List<List<Integer>> levelOrder_02(TreeNode root){
        //定义结果集
        List<List<Integer>> result = new ArrayList<>();
        //定义队列
        Queue<TreeNode> queue = new LinkedList<>();
        if(root!=null){
            queue.offer(root);
        }
        while(!queue.isEmpty()){
            //开始遍历队列,层级遍历
            List<Integer> item = new ArrayList<>();
            // 现获取队列已有的长度，这步非常关键！！！！，记录该层级的元素个数
            int size = queue.size();

            while (size > 0 ){
                //这里不能使用 queue.size()，
                // 因为 queue.size() 是一个动态值，如果使用queue.size()，会把下一层级的节点算上！！
                // size 是一个记录值
                //该层级的元素出队加入集合，直到层级元素个数为0
                final TreeNode poll = queue.poll();
                item.add(poll.getValue());
                size--;
                //将下一层级的元素加入队列
                if(poll.getLeft()!=null ) queue.offer(poll.getLeft());
                if(poll.getRight()!=null ) queue.offer(poll.getRight());

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

226. 翻转二叉树

题目

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

在这里插入图片描述
思路

递归解决

入参，出参：
边界值条件 root == null
最小问题

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

代码实现

public TreeNode reverseTreeNode(TreeNode root){
        if (root != null) {
            return root;
        }
        swap(root);
        reverseTreeNode(root.getLeft());
        reverseTreeNode(root.getRight());
        return root;
    }

    /**
     * 交换是指针交换，不是值交换值！！！
     * @param root
     */
    private void swap(TreeNode root) {
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }

101. 对称二叉树
题目：

给你一个二叉树的根节点 root ，检查它是否轴对称。

思路

递归解决：

何为对称二叉树：简单说就是根节点的子节点可以相互反转
必须是使用 后序遍历 因为只有比较完每个子节点之后，才能确定他们是否对称
- 最小问题：
  - 左右节点比较
  - 只有只有节点相等的情况才返回true,其他情况返回false

代码实现

 public boolean isSymmetric(TreeNode node) {

          return compare(node.left, node.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.value != right.value){
            return false;
        }
        //左侧遍历：左右中  右侧遍历：右左中 
        boolean compareOutSide = compare(left.left,right.right);
        boolean compareInSide = compare(left.right,right.left);
        
        return compareOutSide && compareInSide;

    }