二叉树部分: 层序遍历(10), 226. 翻转二叉树，101. 对称二叉树

已于 2022-10-26 21:39:14 修改
阅读量1.7k 收藏
点赞数
分类专栏： 代码随想录训练营 文章标签： 数据结构 算法
于 2022-10-26 21:37:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34485768/article/details/127526779
版权

代码随想录算法训练营第13天 | 二叉树部分: 层序遍历(10), 226. 翻转二叉树，101. 对称二叉树

二叉树部分

层序遍历

广度遍历：使用队列的方式来实现，当某个节点出队的时候，让它的子节点入队

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

思路：使用一个变量保存每一层的数量，并且在节点出队的时候，其子节点入队
觉得这个代码没有问题，但是结果不对，感觉可能是由于队列方法或者队列的使用的问题，因为debug的时候哦，并不能满足先进先出的规则
错误原因：ArrayDeque中方法的使用问题：使用 pop() push()方法，它们表示对栈的操作，所以才不能满足先进先出的规则

public List<List<Integer>> levelOrder(TreeNode root) {
      List<List<Integer>> res=new ArrayList<>();
      Deque<TreeNode> deque=new LinkedList<>();
      if(root==null){
          return res;
      }
      deque.offer(root);//deque.push(root);
      while(!deque.isEmpty()){
           int size=deque.size();//每一层的大小
            List<Integer> list=new ArrayList<>();
           while(size>0){
               TreeNode node=deque.poll();
               list.add(node.val);
               size--;
               if(node.left!=null){
                   deque.offer(node.left);//deque.push(node.left);//对队列进行更新
               } 
               if(node.right!=null){
                 deque.offer(node.right);//错误的  deque.push(node.right);
               }
           }
           res.add(list);
      }
      return res;
    }

在这里插入图片描述
在这里插入图片描述
补充：LinkedList ArrayDeque的区别：底层数据结构不一样(链表和数组)
Deque中的push poll pop等的区别

Deque双端队列，同样实现了栈的功能
在这里插入图片描述

107. 二叉树的层序遍历 II

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

思路：先按照上面的题做，最后对结果进行翻转
答案：哈哈哈哈哈哈哈哈哈哈哈，就是这个思路，但是直接对res结果集采用reverse()函数出现错误，集合中不支持这个方法,使用循环来解决

public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res=new LinkedList<>();
      Deque<TreeNode> deque=new LinkedList<>();
      if(root==null){
          return res;
      }
      deque.offer(root);//deque.push(root);
      while(!deque.isEmpty()){
           int size=deque.size();//每一层的大小
            List<Integer> list=new ArrayList<>();
           while(size>0){
               TreeNode node=deque.poll();
               list.add(node.val);
               size--;
               if(node.left!=null){
                   deque.offer(node.left);
               } 
               if(node.right!=null){
                 deque.offer(node.right);
               }
           }
           res.add(list);
      }
      //这边没写出来，需要注意
      List<List<Integer>> resList=new LinkedList<>();
      for(int i=res.size()-1;i>=0;i--){
          resList.add(res.get(i));
      }
      return resList;
    }

199. 二叉树的右视图

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

在这里插入图片描述
思路：还是采用层序遍历，维护一个size表示每一层的大小，当size==1的时候，把这个元素保存在结果集中

 public List<Integer> rightSideView(TreeNode root) {
      List<Integer> res=new LinkedList<>();
      Deque<TreeNode> deque=new ArrayDeque<>();
      if(root==null){
          return res;
      }
      deque.offer(root);
      while(!deque.isEmpty()){
          int size=deque.size();
          while(size>0){
              if(size==1){
                   res.add(deque.peek().val);//这边的一个判断比较重要
              }
              TreeNode node =deque.poll();
              size--;
              if(node.left!=null){
                  deque.offer(node.left);
              }
              if(node.right!=null){
                  deque.offer(node.right);
              }
          }
      }
      return res;
    }

637. 二叉树的层平均值

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

思路：使用变量保存每一层的元素个数和元素和，这边的10-5 这个知识点不会，补充

  public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res=new LinkedList<>();
        Deque<TreeNode> deque=new ArrayDeque<>();
        if(root==null){
            return res;
        }
        deque.offer(root);
        while(!deque.isEmpty()){
            int size=deque.size();
            int sizeOr=size;
            double sum=0.0;
            while(size>0){
                TreeNode node=deque.poll();
                size--;
                sum +=node.val;
                if(size==0){
                    res.add(sum/sizeOr);//这边存在一点问题，刚开始除以size，一直出现Nan的错误，但是其实此时size=0,所以才会报错，使用一个变量来保存队列容量的原始值就可以了
                }
                if(node.left!=null){
                    deque.offer(node.left);
                }
                if(node.right!=null){
                    deque.offer(node.right);
                }
            }
        }
        return res;
    }

429. N 叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

思路：n叉树的定义

public class NTreeNode{
   public int val;
   public List<NTreeNode> child;//多叉树的子节点的表示，使用列表来表示
   public NTreeNode(){};
   public NTreeNode(int val){
   this.val=val;
   }
    public NTreeNode(int val, List<NTreeNode> child){
    this.val=val;
    this.child=child;
   }
} 

public List<List<Integer>> levelOrder(Node root) {
       List<List<Integer>> res=new LinkedList<>();
       if(root==null){
           return res;
       }
       Deque<Node> deque=new ArrayDeque<>();
       deque.offer(root);
       while(!deque.isEmpty()){
           int size=deque.size();
            List<Integer> list=new LinkedList<>();
           while(size>0){
               Node node=deque.poll();
               list.add(node.val);
               size--;//注意不要忘了
               if(node.children!=null){
                   List<Node> nodeList=node.children;
                   //使用循环实现子节点的遍历
                  for(int i=0;i<nodeList.size();i++){
                      deque.offer(node.children.get(i));
                  }
               }
           }
           res.add(list);
       }
       return res;
    }

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

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

使用一个变量保存每层中的最大值

 public List<Integer> largestValues(TreeNode root) {
     List<Integer> res=new LinkedList<>();
     Deque<TreeNode> deque=new ArrayDeque<>();
     if(root==null){
         return res;
     }
     deque.offer(root);
     while(!deque.isEmpty()){
         int size=deque.size();
         int max=Integer.MIN_VALUE;//保存每层中的最大值
          while(size>0){
              TreeNode node =deque.poll();
              if(max<node.val){
                  max=node.val;//最大值的更新
              }
              size--;
              if(node.left!=null){
                  deque.offer(node.left);
              }
              if(node.right!=null){
                  deque.offer(node.right);
              }
          }
          res.add(max);
     }
     return res;
    }

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

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下，填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。
struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

在这里插入图片描述

思路：如果size=1的话，那么next=null, 否则next等于待出队的节点

 public Node connect(Node root) {
      Deque<Node> deque=new ArrayDeque<>();
      if(root==null){
          return root;
      }
      deque.offer(root);
      while(!deque.isEmpty()){
          int size=deque.size();
          while(size>0){
              Node node=deque.poll();
              size--;
              if(size==0){
                  node.next=null;//主要的逻辑在这边，如果此时队列中没有其他的节点，表示是最右边的节点，指向null
              }else{
                  node.next=deque.peek();//否则的话指向队列中的对头元素
              }
              if(node.left!=null){
                  deque.offer(node.left);
              }

              if(node.right!=null){
                  deque.offer(node.right);
              }
          }
      }
      return root;
    }

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

给定一个二叉树，填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。
struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

思路，这个题和上一个题是一个思路，只不过这边的二叉树结构不确定是完全二叉树，就是普通二叉树，但是对结果是没有影响的，所以采用相同的代码

public Node connect(Node root) {
           Deque<Node> deque=new ArrayDeque<>();
      if(root==null){
          return root;
      }
      deque.offer(root);
      while(!deque.isEmpty()){
          int size=deque.size();
          while(size>0){
              Node node=deque.poll();
              size--;
              if(size==0){
                  node.next=null;//主要的逻辑在这边，如果此时队列中没有其他的节点，表示是最右边的节点，指向null
              }else{
                  node.next=deque.peek();//否则的话指向队列中的对头元素
              }
              if(node.left!=null){
                  deque.offer(node.left);
              }

              if(node.right!=null){
                  deque.offer(node.right);
              }
          }
      }
      return root;
    }

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。

思路：二叉树的最大深度也就是二叉树层序遍历的层数，使用一个变量记录二叉树的层数

 public int maxDepth(TreeNode root) {
     int level=0;
     Deque<TreeNode> deque=new ArrayDeque<>();
     if(root==null){
         return 0;
     }
     deque.offer(root);
     while(!deque.isEmpty()){
         int size=deque.size();
         //while循环表示一层的遍历
         while(size>0){
             TreeNode node=deque.poll();
             size--;
             if(node.left!=null){
                 deque.offer(node.left);
             }
             if(node.right!=null){
                 deque.offer(node.right);
             }
         }
         level++;
     }
     return level;
    }

111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。说明：叶子节点是指没有子节点的节点。

思路：层序遍历第一次遇到的叶子节点所在的层数即为二叉树的最小深度

public int minDepth(TreeNode root) {
     int level=0;
     Deque<TreeNode> deque=new ArrayDeque<>();
     if(root==null){
         return 0;
     }
     deque.offer(root);
     while(!deque.isEmpty()){
         int size=deque.size();
         level ++;//这边提前更新深度
         while(size>0){
             TreeNode node=deque.poll();
             size--;
             if(node.left==null && node.right==null){
                 return level;//保证一但遇到叶子节点直接退出，此时的深度已经是更新的状态
             }
             if(node.left!=null){
                 deque.offer(node.left);
             }
             if(node.right!=null){
                 deque.offer(node.right);
             }
         }
     }
     return level;
    }

226. 翻转二叉树

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

在这里插入图片描述
思路：正常的层序遍历的顺序是从左到右，既然要实现二叉树的翻转，试试先右再左的方法，暂时感觉就是仅仅改变了队列里面的顺序，实际上二叉树的结构并没有发生变化，感觉这个题目不适合使用层序遍历来做

public TreeNode invertTree(TreeNode root) {
      Deque<TreeNode> deque=new ArrayDeque<>();
      if(root==null){
          return root;
      }
      deque.offer(root);
      while(!deque.isEmpty()){
          int size=deque.size();
          while(size>0){
              TreeNode node=deque.poll();
              size--;
              //这边我以为先右边入队，后左边入队会改变树的左右结构，但是实际上没有
              //即只是改变了队列的顺序，实际上对于节点的左右儿子之间的关系并没有实现相应的改变
              if(node.right!=null){
                  deque.offer(node.right);
              }
               if(node.left!=null){
                  deque.offer(node.left);
              }
              
          }
      }
      return root;
    }

使用递归的方式来实现

public TreeNode invertTree(TreeNode root) {
        invertT(root);
        return root;
    }
    public void invertT(TreeNode root){
        if(root==null){
            return;
        }
        //左右子树交换
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
        invertT(root.left);//左子树
        invertT(root.right);//右子树
    }

101. 对称二叉树

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

在这里插入图片描述
思路: 使用递归的方法 递归写不出来，层序遍历的话，队列中是对称的, 感觉也实现不出来
答案：感觉这边是对于左外侧和右外侧比较 左内侧和右内测比较有印象，但是自己除了前三个if语句之外想得到的就是left.val=right.val, 但是这种情况肯定不能返回true,然后就想不出来了

public boolean isSymmetric(TreeNode root) {
        return compare(root.left, root.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;
        }
        //上面的几种条件都想到了，但是想着如果左节点和右节点值相等的话直接返回true不对，然后就想不出来了
        //没想到会是这种实现
        if (left.val != right.val) {
            return false;
        }
        // 比较外侧
        boolean compareOutside = compare(left.left, right.right);
        // 比较内侧
        boolean compareInside = compare(left.right, right.left);
        return compareOutside && compareInside;
    }

总结：对称二叉树里面的递归逻辑没想出来, Deque也实现了栈的功能，注意方法的使用

朴猪厚
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
20230622 | 102. 二叉树的层序遍历、226. 翻转二叉树、101.对称二叉树
qq_45885369的博客
06-22 78
给你二叉树的根节点 root ，返回其节点值的 层序遍历。（即逐层地，从左到右访问所有节点）。示例 1：输入：root = [3,9,20,null,null,15,7]输出：[[3],[9,20],[15,7]]示例 2：输入：root = [1]输出：[[1]]示例 3：输入：root = []输出：[]
python-leetcode面试题解之第101题对称二叉树-题解.zip
04-29
本压缩包文件“python-leetcode面试题解之第101题对称二叉树-题解.zip”专注于解决LeetCode上的第101题——对称二叉树。这道题目在Python编程语言下的解决方案是核心内容，对于准备Python相关职位面试的求职者来说...
二叉树的遍历
Xingyb14的博客
09-11 305
1 概述 二叉树的遍历按遍历顺序有先序遍历、中序遍历、后序遍历、层次遍历四种，先序、中序和后序遍历可以通过递归或非递归的方式实现 。 递归算法实现简单，而非递归算法的执行效率要高于递归算法，借助栈，可以将二叉树的递归遍历算法转换为非递归算法，其中后序遍历的非递归算法较为复杂。 层次遍历需要借助队列实现。 讨论的二叉树采用二叉链表存储结构。 算法中的 visit 函数对结点进行访问，“ 访问 ”...
二叉树的层次遍历及求节点个数的算法
分享不仅为了他人，同时也为了自己
10-23 7643
（1）访问根结点，并将根结点入队； （2）当队列不空时，重复下列操作：    从队列退出一个结点； 若其有左孩子，则访问左孩子，并将其左孩子入队； 若其有右孩子，则访问右孩子，并将其右孩子入队； #include #include typedef struct binode {  char data;  struct binode *lchild
day15二叉树part02 | 层序遍历 10 226.翻转二叉树 101.对称二叉树 2
C_huamao的博客
05-26 440
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
python-leetcode面试题解之对称二叉树.zip
03-06
本压缩包文件"python-leetcode面试题解之对称二叉树.zip"显然是针对Python程序员，特别是那些准备面试的人，重点讲解了如何解决LeetCode上的“对称二叉树”问题。 对称二叉树是二叉树的一种特殊形态，它的左右子树...
剑指Offer(Python多种思路实现):重建二叉树
12-23
重建二叉树是指根据给定的两种遍历序列（如前序遍历和中序遍历）来恢复原始二叉树的数据结构。这个过程在面试中常常作为算法题出现，用来考察候选人的逻辑思维和编程能力。在这个问题中，我们有两个关键的遍历序列：...
python-leetcode面试题解之第156题上下翻转二叉树-题解.zip
05-14
本篇文章将详细解析LeetCode面试题中的第156题——上下翻转二叉树。 题目描述： 这道题目要求我们实现一个函数，该函数接收一个二叉树的根节点，并对其进行上下翻转的操作。这里的上下翻转意味着原树的每个节点的左...
二叉树-翻转二叉树动画图
10-07
在"二叉树--翻转二叉树动画图"中，我们可以理解为该资源提供了一个动态的视觉展示，帮助学习者直观地理解翻转二叉树的过程。通过HTML5技术，这个动画可能使用SVG（可缩放矢量图形）或者Canvas元素来创建交互式的树...
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1072
可以参考以下视频。
数据结构day3
qq_55245263的博客
07-18 287
顺序表实现学生管理系统
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 721
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
数据结构---二叉树
weixin_47808575的博客
07-22 63
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构第35节 性能优化 算法的选择
hummhumm的专栏
07-18 741
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
【数据结构】堆的实现以及建堆算法和堆排序
2301_81670477的博客
07-19 979
哈喽，各位小伙伴大家好！上期给大家讲了树，二叉树以及堆。今天带着大家实现堆这个数据结构，以及堆排序。话不多说，咱们进入正题！向大厂冲锋！
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1103
24暑假刷题day15打卡 二叉树进阶
数据结构~~顺序表
最新发布
TU^的博客
07-22 388
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
数据结构和算法（刷题）- 用栈实现队列
yunshancangcang_的博客
07-19 370
出队涉及AB两栈的迁移。这是均摊时间复杂度，均摊到每次出队上就是。只用1个栈肯定不行，得用两个栈。思考：入队的时间复杂度显然是。思路：一个栈A，一个栈B。
c++实现以下功能1.创建二叉树 2.先序遍历二叉树 3.中序遍历二叉树1 4.中序遍历二叉树2 5.后序遍历二叉树 6.层序遍历二叉树 7.求二叉树的深度 8.退出
05-12
6. 层序遍历二叉树：从上到下、从左到右依次遍历每一层节点。 7. 求二叉树的深度：可以采用递归方式求解，分别求出左子树和右子树的深度，然后取较大值加1即为二叉树的深度。 8. 退出：程序结束。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值