剑指offer-面试题32：从上到下打印二叉树

最新推荐文章于 2022-02-23 21:17:24 发布

xqxls1

最新推荐文章于 2022-02-23 21:17:24 发布

阅读量215

点赞数

分类专栏：数据结构和算法文章标签：二叉树队列数据结构算法 leetcode

本文链接：https://blog.csdn.net/qq_43568109/article/details/115941827

版权

数据结构和算法专栏收录该内容

80 篇文章 2 订阅

订阅专栏

题目描述

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
例如: 给定二叉树: [3,9,20,null,null,15,7],
  3    
 / \   
9  20
   /  \    
  15   7 
返回：

[3,9,20,15,7]

提示：
节点总数 <= 1000

方法一（BFS）

1.解题思路

通过一个队列存储每一层的元素，然后，一层一层地打印，如果还有下一层，则不断地加入到队列，再继续打印。

2.代码实现

class Solution {
    public int[] levelOrder(TreeNode root) {
        if(root==null) return new int[0];
        LinkedList<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        int[] res=new int[1010];
        int id=0;
        while(queue.size()>0){
            TreeNode node=queue.poll();
            res[id++]=node.val;
            if(node.left!=null){
                queue.offer(node.left);
            }
            if(node.right!=null){
                queue.offer(node.right);
            }
        }
        return Arrays.copyOf(res,id);
    }
}

3.复杂度分析

时间复杂度：需要访问二叉树中每个节点一次，所以时间复杂度为O(n)
空间复杂度：需要额外长度为n的队列来存储入栈元素，所以空间复杂度为O(n)

方法二（递归）

1.解题思路

用一个变量记录当前的层数，一个二维list存储每一层的节点，如果当前层不小于list的大小，则添加一个一维list，并将当前层赋值给这个list。然后分别通过左右子树，往下一层递归。

2.代码实现

class Solution {
    ArrayList<ArrayList<Integer>> list=new ArrayList<>();
    public int[] levelOrder(TreeNode root) {
        dfs(root,0);   
        ArrayList<Integer> temp=new ArrayList<>();    
        for(int i=0;i<list.size();i++){
            temp.addAll(list.get(i));
        }
        int[] res=new int[temp.size()];
        for(int i=0;i<temp.size();i++){
            res[i]=temp.get(i);
        }
        return res;
    }

    public void dfs(TreeNode root,int level) {   
        if(root==null) return;    
        if(level>=list.size()){
            list.add(new ArrayList<>());
        }
        list.get(level).add(root.val);
        dfs(root.left,level+1);
        dfs(root.right,level+1);      
    }
}

3.复杂度分析

时间复杂度：需要访问二叉树中每个节点一次，所以时间复杂度为O(n)
空间复杂度：需要额外长度为n的list来存储所有节点，所以空间复杂度为O(n)

扩展（之字形打印二叉树）

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
例如: 给定二叉树: [3,9,20,null,null,15,7],
     3   
    / \   
   9  20
     /  \    
    15   7 
返回其层次遍历结果：
[ [3],
[20,9],
[15,7] ]

提示：
节点总数 <= 1000

方法一（BFS+奇偶层判断）

1.解题思路

主体思路和常规的BFS层序遍历相同，打印的时候，如果当前层是奇数层，则从前向后打印，如果当前层是偶数层，则从后向前打印。

2.代码实现

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res=new ArrayList<>();
        if(root==null) return res;
        TreeNode node=null;
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int n=queue.size();
            LinkedList<Integer> list=new LinkedList<>();
            while(n>0){
                node=queue.poll();
                if(res.size()%2==0){
                    list.addLast(node.val);
                } 
                else{
                    list.addFirst(node.val);
                }
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
                n--;
            }
            res.add(list);
            
        }
        return res;
    }
}

3.复杂度分析

时间复杂度：需要访问二叉树中每个节点一次，所以时间复杂度为O(n)
空间复杂度：需要额外长度为n的队列来存储入栈元素，所以空间复杂度为O(n)

方法二（BFS+反转）

1.解题思路

最后打印的时候，如果当前层是偶数层，则反转临时的list，然后再打印。

2.代码实现

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res=new ArrayList<>();
        if(root==null) return res;
        TreeNode node=null;
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int n=queue.size();
            List<Integer> list=new ArrayList<>();
            while(n>0){
                node=queue.poll();
                list.add(node.val);               
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
                n--;
            }
            if(res.size()%2==1) Collections.reverse(list);
            res.add(list);
            
        }
        return res;
    }
}

3.复杂度分析

时间复杂度：需要访问二叉树中每个节点一次，所以时间复杂度为O(n)
空间复杂度：需要额外长度为n的队列来存储入栈元素，所以空间复杂度为O(n)

扩展（按前序、中序、后序遍历二叉树）

给你二叉树的根节点 root ，返回它节点值的前序遍历、中序遍历和后序遍历。
示例 1：
   1    
    \   
     2
    /   
   3   
输入：root = [1,null,2,3]
前序输出：[1,2,3]
中序输出：[1,3,2]
后序输出：[3,2,1]

提示：
树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

进阶：递归算法很简单，你可以通过迭代算法完成吗？

方法一（递归）

1.解题思路

递归的思路很简单，就是不断按照对应顺序（前序：根左右，中序：左根右，后序：左右根）打印当前节点，当没有节点可打印时，递归终止。

2.代码实现

前序：

class Solution {
    List<Integer> res=new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        preorder(root);
        return res;
    }
    private void preorder(TreeNode root){
        if(root==null) return;
        res.add(root.val);
        preorder(root.left);
        preorder(root.right);
    }
}

中序：

class Solution {
    List<Integer> res=new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
        inorder(root);
        return res;
    }

    private void inorder(TreeNode root){
        if(root==null) return;     
        inorder(root.left);
        res.add(root.val);
        inorder(root.right);
    }
}

后序：

class Solution {
    List<Integer> res=new ArrayList<>();
    public List<Integer> postorderTraversal(TreeNode root) {
        postorder(root);
        return res;
    }

    private void postorder(TreeNode root){
        if(root==null) return;     
        postorder(root.left);      
        postorder(root.right);
        res.add(root.val);
    }
}

3.复杂度分析

时间复杂度：需要访问二叉树中每个节点一次，所以时间复杂度为O(n)
空间复杂度：最坏情况下，递归栈的深度为树中节点个数，所以空间复杂度为O(n)

方法二（迭代）

1.解题思路

前序1的思路是，先找到当前节点的最左子节点，如果存在，则一直找，每次查找之前打印节点，然后如果没有左节点，则找当前节点右子节点。（前序1是一个比较通用的模板）

前序2的思路是，利用栈的先进后出特性，每次打印后，先让右子节点入栈，再让左子节点入栈，所以最后的顺序是根左右。

中序1的思路和前序1一模一样，只是找到最左子节点后，从最左子节点开始打印。由于栈的先进后出特性，所以最终顺序是左根右。

后序1的思路和前序1的类似，不过是先找到最右子节点，然后在找左子节点，所以顺序是根右左，而后序遍历是左右根，所以还需要反转一下。

后序2、后序3的思路和前序2的类似，最后反转的思路一个是利用集合提供的反转方法，一个通过栈进行反转。

后序4的思路和前序2的类似，不过通过一个变量记录上次打印的节点。如果当前层左右子节点均没有打印，先打印左子节点；如果左子节点打印了，右子节点还没有打印，则打印右子节点；最后考虑当前节点。

2.代码实现

前序1：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list=new LinkedList<Integer>();
        LinkedList<TreeNode> s=new LinkedList<TreeNode>();
        TreeNode node=root;
        while(node!=null||!s.isEmpty()){
            if(node!=null){
                s.push(node);
                list.add(node.val);
                node=node.left;
            }
            else{
                node=s.pop();
                node=node.right;
            }
            
        }

        return list;
    }
}

前序2：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        if(root==null) return res;
        LinkedList<TreeNode> stack=new LinkedList<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node=stack.pop();
            res.add(node.val);
            if(node.right!=null){
                stack.push(node.right);
            }
            if(node.left!=null){
                stack.push(node.left);
            }
        }
        return res;
    }
}

中序1：

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list=new LinkedList<Integer>();
        LinkedList<TreeNode> s=new LinkedList<>();
        TreeNode node=root;
        while(node!=null||!s.isEmpty()){
            if(node!=null){
                s.push(node);
                node=node.left;
            }
            else{
                node=s.pop();
                list.add(node.val);
                node=node.right;
            }
        }
        return list;
    }
}

后序1：

class Solution {
    
    public List<Integer> postorderTraversal(TreeNode root) {   
        List<Integer> res=new ArrayList<Integer>();    
        if(root==null) return res;
        ArrayDeque<TreeNode> s=new ArrayDeque<>();
        TreeNode node=root;
        while(!s.isEmpty()||node!=null){
            if(node!=null){
                s.push(node);
                res.add(node.val);
                node=node.right;
            }
            else{
                node=s.pop();
                node=node.left;
            }
        }
        Collections.reverse(res);
        return res;
    }
}

后序2：

class Solution {
    
    public List<Integer> postorderTraversal(TreeNode root) {   
        List<Integer> res=new ArrayList<Integer>();    
        if(root==null) return res;
        ArrayDeque<TreeNode> s=new ArrayDeque<>();
        TreeNode node=root;
        while(!s.isEmpty()||node!=null){
            if(node!=null){
                s.push(node);
                res.add(node.val);
                node=node.right;
            }
            else{
                node=s.pop();
                node=node.left;
            }
        }
        Collections.reverse(res);
        return res;
    }
}

后序3：

class Solution {
    
    public List<Integer> postorderTraversal(TreeNode root) {   
        List<Integer> res=new ArrayList<Integer>();    
        if(root==null) return res;
        LinkedList<TreeNode> s1=new LinkedList<>();
        LinkedList<TreeNode> s2=new LinkedList<>();
        s1.push(root);
        while(!s1.isEmpty()){
            TreeNode node=s1.pop();
            s2.push(node);
            if(node.left!=null){
                s1.push(node.left);
            }
            if(node.right!=null){
                s1.push(node.right);
            }           
        }
        while(!s2.isEmpty()){
            res.add(s2.pop().val);
        }
        return res;
    }
}

后序4：

class Solution {
    
    public List<Integer> postorderTraversal(TreeNode root) {   
        List<Integer> res=new ArrayList<Integer>();    
        if(root==null) return res;
        Deque<TreeNode> s=new LinkedList<>();
        s.push(root);
        TreeNode p=root;
        while(!s.isEmpty()){
            TreeNode node=s.peek();
            if(node.left!=null&&p!=node.left&&p!=node.right){
                s.push(node.left);
            }
            else if(node.right!=null&&p!=node.right){
                s.push(node.right);
            }   
            else{
                res.add(s.pop().val);
                p=node;
            }        
        }
        return res;
    }
}

3.复杂度分析

时间复杂度：需要访问二叉树中每个节点一次，所以时间复杂度为O(n)
空间复杂度：前序和中序均需要一个栈的额外空间开销，后序1到3除了需要一个栈的开销，还需要另一个栈或者集合方法来反转，后序4利用节点变量，避免了反转操作，一需要一个栈的空间开销，空间复杂度为均为O(n)

剑指offer全集入口：请戳这里

xqxls1

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
剑指offer-面试题32：从上到下打印二叉树

题目描述从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。例如: 给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回：[3,9,20,15,7]提示：节点总数 <= 1000方法一（BFS）1.解题思路通过一个队列存储每一层的元素，然后，一层一层地打印，如果还有下一层，则不断地加入到队列，再继续打印。2.代码实现class Solution {
复制链接

扫一扫