leetcode.102/107 二叉树层序遍历

最新推荐文章于 2022-05-20 17:56:06 发布

qq_40396568

最新推荐文章于 2022-05-20 17:56:06 发布

阅读量1k

点赞数

分类专栏： leetcode

本文链接：https://blog.youkuaiyun.com/qq_40396568/article/details/119078763

版权

leetcode 专栏收录该内容

36 篇文章

订阅专栏

这篇博客介绍了两种解决LeetCode上102和107题——二叉树层序遍历的方法。首先，通过BFS（广度优先搜索）进行层序遍历，时间复杂度为O(n)，空间复杂度为O(n)。其次，使用DFS（深度优先搜索）来遍历，重点在于如何在适当的时候创建新的子集合。文章还提到了不同实现方式的时间和空间复杂度，包括使用LinkedList和ArrayList的区别。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

思路一：bfs广度优先模板化就是利用一个队列


class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if(root==null)
        return result;
        Queue<TreeNode> queue=new LinkedList();
        queue.add(root);
        while(!queue.isEmpty())
        {
            int len=queue.size();
            List<Integer> list = new ArrayList<>();
            while(len>0)
            {
                TreeNode node = queue.poll();
                list.add(node.val);
//这个地方卡半天，是node.left不是root.left,总是盯着根节点根干嘛
                if(node.left!=null)
                {
                    queue.add(node.left);
                }
                if(node.right!=null)
                {
                    queue.add(node.right);
                }
                len--;
            }
            result.add(list);
        }
        return result;
    }
}

复杂度

时间O（n）

空间O （n）队列长度

思路二：dfs

每遍历一个新的深度，创建一个新的子集合，用于存储该层次的节点，再次遍历同一深度节点时不创建集合，需要将该节点加入子集和的尾

难点：什么时候创建子集合，取出该层次子集合

对什么时候应该new 一个集合的注解

未完待续

代码实现如下：


class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        dfs(root,1,result);
        return result;
    }
    private void dfs(TreeNode node,int level,List<List<Integer>> result)
    {
        if(node==null)
        return;
        if(level>result.size())
        {
            result.add(new ArrayList<>());
        }
        result.get(level-1).add(node.val);
        if(node.left!=null)
        {
            dfs(node.left,level+1,result);
        }
        if(node.right!=null)
        {
            dfs(node.right,level+1,result);
        }
    }
}


class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if(root==null)
        return result;
        dfs(root,result,0);
        return result;
    }
    private  void dfs(TreeNode node,List<List<Integer>> result,int level)
    {
        if(node==null)
        return;
        if(level>result.size()-1)
        result.add(new ArrayList<>());
        result.get(level).add(node.val);
        dfs(node.left,result,level+1);
        dfs(node.right,result,level+1);
    }
}

leetcode.107 二叉树层序遍历2

方式一：bfs之后翻转list


class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if(root==null)
        return result;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(queue.size()>0)
        {
            int len=queue.size();
            List<Integer> list = new ArrayList<>();
            while(len>0)
            {
                TreeNode node=queue.poll();
                list.add(node.val);
                if(node.left!=null)
                {
                    queue.add(node.left);
                }
                if(node.right!=null)
                {
                    queue.add(node.right);
                }
                len--;
            }
            result.add(list);
        }
        Collections.reverse(result);
        return result;
    }
}

复杂度

时间访问每个节点为O（n）,列表翻转也为O（n）,总时间复杂度O（n）

空间队列长度O（n）

方式二bfs（底层使用LinkedList+头插法）

【如果使用arraylist插入数组头部为O（n，链表插入为O（1））】


class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
       
        List<List<Integer>> result = new LinkedList<>();//ArrayList
        if(root==null)
        return result;
        Queue<TreeNode> queue=new LinkedList();
        queue.add(root);
        while(!queue.isEmpty())
        {
            int len=queue.size();
            List<Integer> list = new ArrayList<>();
            while(len>0)
            {
                TreeNode node = queue.poll();
                list.add(node.val);
//这个地方卡半天，是node.left不是root.left,总是盯着根节点根干嘛
                if(node.left!=null)
                {
                    queue.add(node.left);
                }
                if(node.right!=null)
                {
                    queue.add(node.right);
                }
                len--;
            }
            result.add(0,list);
        }
        return result;

    }
}

数组的一次插入是O（n）

方式三：dfs（列表翻转）


class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if(root==null)
        return result;
        dfs(root,result,0);
        Collections.reverse(result);
        return result;
    }
    private  void dfs(TreeNode node,List<List<Integer>> result,int level)
    {
        if(node==null)
        return;
        if(level>result.size()-1)
        result.add(new ArrayList<>());
        result.get(level).add(node.val);
        if(node.left!=null)//多一个判断beat反而更少了，两行代码的消耗比多压一次栈，占用内存多？
        dfs(node.left,result,level+1);
        if(node.right!=null)
        dfs(node.right,result,level+1);
    }
}