从上到下打印二叉树的三种题型

Posted 2021-09-11 你这家伙

从上到下打印二叉树（一）

也就是我们所熟知的层序遍历

思路分析：

1.首先它需要返回的是一个数组，那么我们首先要做的就是new一个数组，而数组的大小需要我们遍历这棵二叉树计算出来
2. 当我们申请完数组之后，然后借助队列来完成层序遍历
3. 首先将根节点放进去，然后当队列不为空的时候，定义一个cur记录这个节点，然后每弹出一个元素，就放进数组里面
4. 然后再判断这个节点的左节点和右节点是否不为空，当不为空的时候放进队列

//首先获取这棵树有多少个节点
    public int getSize(TreeNode root){
        if(root == null){
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int count = 1;
        while(!queue.isEmpty()){
            TreeNode cur = queue.poll();
            if(cur != null){
                if(cur.left != null){
                    queue.offer(cur.left);
                    count++;
                }
                if(cur.right != null){
                    queue.offer(cur.right);
                    count++;
                }
            }
        }
        return count;
    }
    public int[] levelOrder(TreeNode root) {
        if(root == null){
            return new int[]{};
        }
        int length = getSize(root);
        int[] arr = new int[length];
        int i = 0; 
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode cur = queue.poll();
            arr[i] = cur.val;
            i++;
            if(cur != null){
                if(cur.left != null){
                    queue.offer(cur.left);
        
                }
                if(cur.right != null){
                    queue.offer(cur.right);
                   
                }
            }
        }
        return arr; 
    }

从上到下打印二叉树（二）

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

可以看出每一层都是放在一个list里面，最后将全部list放在一个list里面返回，返回类型List<List>

思路分析:
其实这里面最难的点在于什么时候一层被遍历完了呢？
解决办法：那就是将每一层放进去的数据记录下来，也就是队列的大小，然后当队列大小大于0的时候接着遍历，当小于0的时候直接走到下一层

1. 首先判断根节点是否为空，如果为空，那么就直接返回空的ret
2. 借助队列来完成，当队列不为空的时候，此时记录队列元素个数
3. 然后此时创建一个list来存储每一层的所有节点的值
4. 之后当队列不为空的是否，记录队顶弹出的元素，弹出的元素需要放入list当中
5. 然后判断这个队顶元素的左右节点是否为空，如果不为空就直接放入list当中
6. 当每一层遍历完成之后都需要将他在放入ret当中
7. 最后返回ret

public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ret = new ArrayList<>();
        if(root == null){
            return ret;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            while(size > 0){
            TreeNode cur = queue.poll();
            size--;
            list.add(cur.val);
            if(cur.left != null){
                queue.offer(cur.left);
            }
            if(cur.right != null){
                queue.offer(cur.right);
            }
            }
            ret.add(list);
        }
        return ret;
    }

从上到下打印二叉树（三）

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

其实这个题的思路上第二题你的思路基本上一直，这里不同的是，你需要定义一个变量count来判断是奇数层还是偶数层
如果是奇数层的话那就进行尾插，也就是直接add(val)
如果是偶数层的话那就进行头插，也就是add(0 , val)

public List<List<Integer>> levelOrder(TreeNode root) {
             List<List<Integer>> ret = new ArrayList<>();
            if(root == null){
                return ret;
            }
            Queue<TreeNode> queue = new LinkedList<>();
            queue.offer(root);
            int count = 1;
            while(!queue.isEmpty()) {
                int size = queue.size();
                List<Integer> list = new ArrayList<>();
                if (count % 2 != 0) {
                    for(int i = queue.size(); i > 0;i--){
                    TreeNode cur = queue.poll();
                    size--;
                    list.add(cur.val);
                    if (cur.left != null) queue.offer(cur.left);
                    if (cur.right != null) queue.offer(cur.right);
                } 
                }else {
                    for(int i = queue.size(); i > 0;i--){
                    TreeNode cur = queue.poll();
                    size--;
                    list.add(0, cur.val);
                    if (cur.left != null) queue.offer(cur.left);
                    if (cur.right != null) queue.offer(cur.right);
                }
                }
                ret.add(list);
                count++;
            }
            return ret;
        }