day12|层序遍历合集、226.翻转二叉树、101.对称二叉树

news2024/12/30 1:41:17

层序遍历合集

102.二叉树的层序遍历

107.二叉树的层次遍历II

199.二叉树的右视图

637.二叉树的层平均值

429.N叉树的层序遍历

515.在每个树行中找最大值

116.填充每个节点的下一个右侧节点指针

117.填充每个节点的下一个右侧节点指针II

104.二叉树的最大深度

111.二叉树的最小深度

226.翻转二叉树

101.对称二叉树

层序遍历合集

102.二叉树的层序遍历

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

示例 1：

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

输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]

输出：[[1]]

示例 3：

输入：root = []

输出：[]

问题分析：

借助队列，先把元素加入队列中，如果队列长度>0,就把这个元素加到数组中，再去判断是否有左右孩子，如果有就依次加入队列中，当第一层的长度减为0时，则进行下一层的遍历。

方法一：BFS

class Solution {
    public List<List<Integer>> resList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        checkFun(root);
        return resList;
    }
    public void checkFun(TreeNode node){
        if(node==null) return;
        Queue<TreeNode> que=new LinkedList<TreeNode>();
        que.offer(node);

        while (!que.isEmpty()){
            List<Integer> itemList=new ArrayList<Integer>();//数组中的小数组，代表着每一层
            int len=que.size();

            while(len>0){
                TreeNode tmpnode=que.poll();
                itemList.add(tmpnode.val);

                if(tmpnode.left!=null) que.offer(tmpnode.left);
                if (tmpnode.right!=null) que.offer(tmpnode.right);
                len--;

            }
            resList.add(itemList);//把每一层数组加到大数组中
        }

    }
}

107.二叉树的层次遍历II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

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

输出：[[15,7],[9,20],[3]]

示例 2：

输入：root = [1]

输出：[[1]]

示例 3：

输入：root = []

输出：[]

问题分析：

按照102的从上往下遍历：

借助队列，先把元素加入队列中，如果队列长度>0,就把这个元素移除队列，并加到数组中，再去判断是否有左右孩子，如果有就依次加入队列中，当第一层的长度减为0时，则进行下一层的遍历。

最后把数组反转一下

class Solution {

    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> resList = new ArrayList<List<Integer>>();

        if (root == null) return resList;
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(root);
        while (!que.isEmpty()) {
            int len = que.size();
            List<Integer> itemList = new ArrayList<Integer>();
            while (len > 0) {
                TreeNode tmonode = que.poll();
                itemList.add(tmonode.val);
                if (tmonode.left != null) que.offer(tmonode.left);
                if (tmonode.right != null) que.offer(tmonode.right);
                len--;
            }
            resList.add(itemList);
        }
       // List<List<Integer>> result = new ArrayList<>();//用新的大数组存反转后的小数组
       /* for (int i = resList.size() - 1; i >= 0; i--) {//反转操作
            result.add(resList.get(i));
        }*/
      Collections.reverse(resList);
        return resList;
        //retur result;
    }
}

199.二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

输入: [1,2,3,null,5,null,4]

输出: [1,3,4]

示例 2:

输入: [1,null,3]

输出: [1,3]

示例 3:

输入: []

输出: []

问题分析：

层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进list数组中。

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        Queue<TreeNode> qe=new LinkedList<>();
        List<Integer> list=new ArrayList<Integer>();
        if (root==null) return list;

        qe.offer(root);
        while (!qe.isEmpty()){
            int len= qe.size();
          for(int i=0;i<len;i++) {
              TreeNode node = qe.poll();

              if (node.left != null) qe.offer(node.left);
              if (node.right != null) qe.offer(node.right);
                //把right放到left后面目的是让其作为最后面的元素

              if(i==len-1){
                  list.add(node.val);
              }
          }
        }
        return list;
    }
}

637.二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

示例 1：

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

输出：[3.00000,14.50000,11.00000]

解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。因此返回 [3, 14.5, 11] 。

示例 2:

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

输出：[3.00000,14.50000,11.00000]

问题分析：

本题就是层序遍历的时候把一层求个总和，再取一个均值

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> list=new ArrayList<>();
        Queue<TreeNode> qe=new LinkedList<>();
        if(root==null) return list;

        qe.offer(root);
        while(!qe.isEmpty()){
            int len= qe.size();
            double sum=0.0;
          for(int i=0;i<len;i++){
                TreeNode node=qe.poll();
                sum=sum+node.val;
                if(node.left!=null) qe.offer(node.left);
                if(node.right!=null) qe.offer(node.right);

            }
            list.add(sum/len);//最好不要对len操作 例如while(len>0)最后len--
        }
        return list;
    }
}