力扣刷题 二叉树的层级遍历

二叉树的层级遍历

二叉树的层级遍历可以说是个套路，主要思想是借助一个队列的实现，先将根节点入队，开启循环，队空的时候退出，循环的内容为： 根节点出队，如果根节点有左子树，入队，如果根节点有右子树，入队。

剑指 Offer 32 - I. 从上到下打印二叉树

题意：从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

计算流程

1. 判断根节点是否为空，若为空则返回null，不为空则向队列添加根节点
2. 循环（当队列不为空时）
   1. 出队： 队首元素出队，记为 node；
   2. 打印： 将 node.val 添加至列表 tmp 尾部；
   3. 添加子节点： 若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 queue ；
3. 返回打印结果列表 res 即可。

class Solution {
   public int[] levelOrder(TreeNode root) {
       if(root == null){
           return new int[0];
       }
       Queue<TreeNode> queue = new LinkedList<>();
       List<Integer> list = new ArrayList<>();
       queue.add(root);
       while(!queue.isEmpty()){
           TreeNode node = queue.poll();
           list.add(node.val);
           if(node.left != null){
               queue.add(node.left);
           }
           if(node.right != null){
               queue.add(node.right);
           }
       }
       int i = 0;
       int[] result = new int[list.size()];
       for(int num : list){
           result[i++] = num;
       }
       return result;
   }
}

剑指 Offer 32 - II. 从上到下打印二叉树 II

题意：从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

计算流程

1. 判断根节点是否为空，若为空则返回null，不为空则向队列添加根节点
2. 循环（当队列不为空时）
   1.新建一个临时列表 tmp ，用于存储当前层打印结果；
   2.当前层打印循环： 循环次数为当前层节点数（即队列 queue 长度）；
   1. 出队： 队首元素出队，记为 node；
   2. 打印： 将 node.val 添加至列表 tmp 尾部；
   3. 添加子节点： 若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 queue ；
3. 返回打印结果列表 res 即可。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Deque<TreeNode> tree = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        if(root == null){
            return res;
        }
        tree.add(root);
        while(tree.size() > 0){
            List<Integer> arrList = new ArrayList<>();
            for(int i = tree.size(); i > 0; i--){
                TreeNode temp = tree.pop();
                arrList.add(temp.val);
                if(temp.left != null){
                    tree.add(temp.left);
                }
                if(temp.right != null){
                    tree.add(temp.right);
                }
            }
            res.add(arrList);
        }
        return res;
    }
}

剑指 Offer 32 - III. 从上到下打印二叉树 III

题意：请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

计算流程

1. 判断根节点是否为空，若为空则返回null，不为空则向队列添加根节点
2. 循环（当队列不为空时）
   1.新建一个临时列表 list ，用于存储当前层打印结果；
   2.当前层打印循环： 循环次数为当前层节点数（即队列 queue 长度）；
   1. 出队： 队首元素出队，记为 node；
   2. 打印：判断该节点所在层数为奇数层还是偶数层，若为奇数层则节点从队列尾部插入，若为偶数层则从队列头部插入，以此实现Z形排列
   3. 添加子节点： 若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 queue ；
3. 返回打印结果列表 res 即可。

class Solution {
   public List<List<Integer>> levelOrder(TreeNode root) {
       //主要是奇偶分层，奇数层节点放队列尾，偶数节点放队列头
       List<List<Integer>> result = new ArrayList<>();
       Queue<TreeNode> queue = new LinkedList<>();
       if(root != null){
           queue.add(root);
       }
       while(! queue.isEmpty()){
           LinkedList<Integer> list = new LinkedList<>();
           for(int i = queue.size(); i > 0; i--){
               TreeNode cur = queue.poll();            
               //判断该节点在奇数层还是偶数层
               if(result.size() % 2 == 0){  //“==0”说明节点在奇数层
                   list.addLast(cur.val);
               }else{
                   list.addFirst(cur.val);
               }
               if(cur.left != null){
                   queue.add(cur.left);
               }
               if(cur.right != null){
                   queue.add(cur.right);
               }
           }
           result.add(list);
       }
       return result;
   }
}