LeetCode-探索-初级算法-树-4. 二叉树的层次遍历(个人做题记录，不是习题讲解)

LeetCode-探索-初级算法-树-4. 二叉树的层次遍历(个人做题记录，不是习题讲解)

LeetCode探索-初级算法：https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/

4. 二叉树的层次遍历

• 语言：java

• 思路：本来想直接BFS，后面想想就算BFS，也得知道什么时候存进List。后面想想好像可以for循环直接通过数量1 2 4 8等决定展示，所以好像不是问题（后面写完后也是错的，因为忽略了如果树是单排的情况）。看来还是必须边遍历就边决策如何存放List了

• 参考代码1(1ms)：即BFS每层都直接记录到List存进去，我之前失败的原因主要就是没能处理好这个List存储。

  https://www.cnblogs.com/patatoforsyj/p/9496127.html

  /**
  * Definition for a binary tree node.
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
  *     TreeNode(int x) { val = x; }
  * }
  */
  class Solution {
      List<List<Integer>> res=new ArrayList();
      public List<List<Integer>> levelOrder(TreeNode root) {
         if(root==null)return res;                                //边界条件
         
          Queue<TreeNode> q=new LinkedList();             //创建的队列用来存放结点，泛型注意是TreeNode
          q.add(root);                                
          while(!q.isEmpty()){                        //队列为空说明已经遍历完所有元素，while语句用于循环每一个层次
              int count=q.size();     
               List<Integer> list=new ArrayList();
              while(count>0){                             //遍历当前层次的每一个结点，每一层次的Count代表了当前层次的结点数目
                  TreeNode temp=q.peek();
                  q.poll();                                        //遍历的每一个结点都需要将其弹出
                  list.add(temp.val);
                  if(temp.left!=null)q.add(temp.left);      //迭代操作，向左探索
                  if(temp.right!=null)q.add(temp.right);
                  count--;
              }
              res.add(list);
          }
          return res;
     
      }
  }
  

• 参考代码2(1ms):利用类似前序遍历的方式，边遍历边传入层数进行记录

  /**
   * Definition for a binary tree node.
   * public class TreeNode {
   *     int val;
   *     TreeNode left;
   *     TreeNode right;
   *     TreeNode(int x) { val = x; }
   * }
   */
  class Solution {
      List<List<Integer>> levels = new ArrayList<List<Integer>>();
      public List<List<Integer>> levelOrder(TreeNode root) {
          if (root == null) return levels;
          helper(root, 0);
          return levels;
      }
      //递归写法
      public void helper(TreeNode node, int level) {
         if(levels.size() == level){
             levels.add(new ArrayList<Integer>());
         }
         levels.get(level).add(node.val);
         if(node.left != null){
            helper(node.left,level+1); 
         }
         if(node.right != null){
             helper(node.right,level+1); 
         }
      }
  }
  

• 参考后重写1(1ms)：感觉参考的那个关键一个我想不到的点就是如何能够记录每一层的节点，参考的利用每次记录队列当前的大小，再内嵌循环的方式实现了每层单独List存储，感觉很巧妙。

  /**
   * Definition for a binary tree node.
   * public class TreeNode {
   *     int val;
   *     TreeNode left;
   *     TreeNode right;
   *     TreeNode(int x) { val = x; }
   * }
   */
  class Solution {
      public List<List<Integer>> levelOrder(TreeNode root) {
          List<List<Integer>> res = new ArrayList();
          if(root==null)
              return res;
          Queue<TreeNode> queue = new LinkedList();
          int count;//我没想到的关键，用来记录每层是否遍历完的计数器
          TreeNode cur = null;
          queue.offer(root);
          while(!queue.isEmpty()){
              count = queue.size();
              List<Integer> vals = new ArrayList();
              while(count-->0){
                  cur = queue.poll();
                  vals.add(cur.val);
                  if(cur.left!=null){
                      queue.offer(cur.left);
                  }
                  if(cur.right!=null){
                      queue.offer(cur.right);
                  }
              }
              res.add(vals);
          }
          return res;
      }
  }
  

• 参考后重写2(1ms)：关键就是层级参数，和判断层级与res的容量相同时新建一个新的list并存入res，每层通过相同层数下标的List来添加数字val

  /**
   * Definition for a binary tree node.
   * public class TreeNode {
   *     int val;
   *     TreeNode left;
   *     TreeNode right;
   *     TreeNode(int x) { val = x; }
   * }
   */
  class Solution {
      List<List<Integer>> res = new ArrayList();
      public List<List<Integer>> levelOrder(TreeNode root) {
          int depth = 0;
          DFS(root,depth);
          return res;
      }
      public void DFS(TreeNode node,int depth){
          if(node!=null){
              if(depth == res.size())
                  res.add(new ArrayList<Integer>());
              if(res.get(depth)!=null)
                  res.get(depth).add(node.val);  
              DFS(node.left,depth+1);
              DFS(node.right,depth+1);
          }
      }
  }