二叉树的层序遍历

二叉树的层序遍历

---

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。

需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

使用队列实现二叉树广度优先遍历，动画如下：

代码：
力扣题目：102.二叉树的层序遍历

class Solution {
    public List<List<Integer>> resList = new ArrayList<List<Integer>>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        //checkFun01(root,0);
        checkFun02(root);

        return resList;
    }

    //DFS--递归方式
    public void checkFun01(TreeNode node, Integer deep) {
        if (node == null) return;
        deep++;

        if (resList.size() < deep) {
            //当层级增加时，list的Item也增加，利用list的索引值进行层级界定
            List<Integer> item = new ArrayList<Integer>();
            resList.add(item);
        }
        resList.get(deep - 1).add(node.val);

        checkFun01(node.left, deep);
        checkFun01(node.right, deep);
    }

    //BFS--迭代方式--借助队列
    public void checkFun02(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);
        }

    }
}

力扣题目：二叉树的层次遍历 II

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> list = new ArrayList<>();
        Deque<TreeNode> que = new LinkedList<>();

        if(root == null){
            return list;
        }
        que.offerLast(root);
       while (!que.isEmpty()) {
            List<Integer> levelList = new ArrayList<>();

            int levelSize = que.size();
            for (int i = 0; i < levelSize; i++) {
                TreeNode peek = que.peekFirst();
                levelList.add(que.pollFirst().val);

                if (peek.left != null) {
                    que.offerLast(peek.left);
                }
                if (peek.right != null) {
                    que.offerLast(peek.right);
                }
            }
            list.add(levelList);
        }

        List<List<Integer>> result = new ArrayList<>();
        for (int i = list.size() - 1; i >= 0; i-- ) {
            result.add(list.get(i));
        }

        return result;
    }
}

力扣题目：199. 二叉树的右视图

//解法一：递归
/**
 * 解法：队列，迭代。
 * 每次返回每层的最后一个字段即可。
 */
 public List<Integer> rightSideView(TreeNode root) {
     List<Integer> list = new ArrayList<>();
     Deque<TreeNode> que = new LinkedList<>();

     if (root == null) {
          return list;
      }

      que.offerLast(root);
      while (!que.isEmpty()) {
          int levelSize = que.size();

          for (int i = 0; i < levelSize; i++) {
              TreeNode poll = que.pollFirst();

              if (poll.left != null) {
                  que.addLast(poll.left);
              }
              if (poll.right != null) {
                  que.addLast(poll.right);
              }

              if (i == levelSize - 1) {
                  list.add(poll.val);
              }
          }
      }

      return list;
  }
} 


//小优化：每层右孩子先入队。
public List<Integer> rightSideView(TreeNode root) {
    List<Integer> list = new ArrayList<>();
    Deque<TreeNode> que = new LinkedList<>();

    if (root == null) {
        return list;
    }

    que.offerLast(root);

    while(!que.isEmpty()){
        int len = que.size();

        for (int i = 0; i < len; i++) {
            TreeNode poll = que.pollFirst();

            if (poll.right != null) {
                que.addLast(poll.right);
            }
            if (poll.left != null) {
                que.addLast(poll.left);
            }

            if (i == 0) {
                list.add(poll.val);
            }
        }
    }

    return list;
}

力扣题目：637. 二叉树的层平均值

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

        que.offerLast(root);
        while(!que.isEmpty()){
            int len = que.size();
            double sum = 0.0;

            for(int i = 0; i < len; i++){
                TreeNode poll = que.pollFirst();
                sum += poll.val;

                if (poll.left != null) {
                    que.addLast(poll.left);
                }
                if (poll.right != null) {
                    que.addLast(poll.right);
                }
            }
            list.add(sum / len);
        }
        return list;
    }
}

力扣题目：429. N 叉树的层序遍历

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> list = new ArrayList<>();
        Deque<Node> que = new LinkedList<>();

        if(root == null){
            return list;
        } 

        que.offerLast(root);
        while(!que.isEmpty()){
            int len = que.size();
            List<Integer> item = new ArrayList<>();

            for(int i = 0; i < len; i++){
                Node poll = que.pollFirst();
                item.add(poll.val);

                List<Node> children = poll.children;
                if (children == null || children.size() == 0) {
                    continue;
                }
                for (Node child : children) {
                    if (child != null) {
                        que.offerLast(child);
                    }
                }
            }

            list.add(item);
        }

        return list;
    }
}

力扣题目：515.在每个树行中找最大值

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Deque<TreeNode> que = new LinkedList<>();

        if(root == null){
            return list;
        }

        que.offerLast(root);
        while(!que.isEmpty()){
            int len = que.size();
            int max = Integer.MIN_VALUE;
            for(int i = 0; i < len; i++){
                TreeNode poll = que.pollFirst();
                max = Math.max(max, poll.val);

                if(poll.left != null){
                    que.addLast(poll.left);
                }
                if(poll.right != null){
                    que.addLast(poll.right);
                }
            }
            list.add(max);
        }

        return list;
    }
}

力扣题目：116. 填充每个节点的下一个右侧节点指针

class Solution {
    public Node connect(Node root) {
        Deque<Node> que = new LinkedList<>();

        if(root == null){
            return root;
        }

        que.offerLast(root);
        while(!que.isEmpty()){
            int len = que.size();

            Node cur = que.poll();
            if (cur.left != null) que.add(cur.left);
            if (cur.right != null) que.add(cur.right);

            for(int i = 1; i < len; i++){
               Node next = que.poll();
               if (next.left != null) que.add(next.left);
               if (next.right != null) que.add(next.right);
               cur.next = next;
               cur = next;
            }
        }

        return root;
    }
}

力扣题目：填充每个节点的下一个右侧节点指针 II

本题只是换了一种树，但思路代码都是一样的

力扣题目：104. 二叉树的最大深度

class Solution {
    public int maxDepth(TreeNode root) {
        int deep = 0;
        Deque<TreeNode> que = new LinkedList<>();

        if(root == null){
            return deep;
        }

        que.offerLast(root);
        while(!que.isEmpty()){
            deep++;
            int len = que.size();

            for(int i = 0; i < len; i++){
                TreeNode node = que.poll();
                if(node.left != null){
                    que.offer(node.left);
                }
                if(node.right != null){
                    que.offer(node.right);
                }
            }
        }

        return deep;
    }
}

力扣题目：111. 二叉树的最小深度

class Solution {
    public int minDepth(TreeNode root) {
        int deep = 0;
        Deque<TreeNode> que = new LinkedList<>();

        if(root == null){
            return deep;
        }

        que.offerLast(root);
        while(!que.isEmpty()){
            deep++;
            int len = que.size();
            while(len > 0){
                TreeNode node = que.poll();
                if(node.left == null && node.right == null){
                    return deep;
                }
                if(node.left != null){
                    que.offer(node.left);
                }
                if(node.right != null){
                    que.offer(node.right);
                }

                len--;
            }
        }
        return deep;
    }
}