Binary Tree Level Order Traversal 二叉树的层序遍历

最新推荐文章于 2024-08-16 09:05:29 发布

chenyx90

最新推荐文章于 2024-08-16 09:05:29 发布

阅读量324

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode

本文链接：https://blog.youkuaiyun.com/chenyx90/article/details/50484980

leetcode 专栏收录该内容

57 篇文章

订阅专栏

该博客介绍了如何实现二叉树的层次遍历，即从左到右按层级逐个返回节点值。例如给定特定的二叉树结构，会展示对应的层次遍历结果。

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

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example:
Given binary tree {3,9,20,#,#,15,7},

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]

有了以前的经历，下边写了最基础的写法，理解比较简单。但是看起来代码量有点多
/** 
 * Definition for a binary tree node. 
 * public class TreeNode { 
 *     int val; 
 *     TreeNode left; 
 *     TreeNode right; 
 *     TreeNode(int x) { val = x; } 
 * } 
 */ 
public class Solution { 
    public List<List<Integer>> levelOrder(TreeNode root) { 
        List<List<Integer>> outter=new ArrayList<List<Integer>>(); 
        List<Integer> inner=new LinkedList<Integer>(); 
        if(root==null)  return outter; 
        inner.add(root.val); 
        outter.add(inner); 
        inner=new LinkedList<Integer>(); 
        int curcount=1; 
        int nexcount=0; 
        Queue<TreeNode> queue=new LinkedList<TreeNode>(); 
        queue.add(root); 
        while(!queue.isEmpty()){ 
            TreeNode node=queue.poll(); 
            --curcount; 
            if(node.left!=null){ 
                queue.add(node.left); 
                inner.add(node.left.val); 
                ++nexcount; 
            } 
            if(node.right!=null){ 
                queue.add(node.right); 
                inner.add(node.right.val); 
                ++nexcount; 
            } 
            if(curcount==0){ 
                curcount=nexcount; 
                nexcount=0; 
                if(!inner.isEmpty()){ 
                    outter.add(inner); 
                    inner=new LinkedList<Integer>(); 
                } 
            } 
        } 
        return outter; 
    } 
}

下边的写法没有对头节点进行特殊处理，包含在了统一的处理范围之内，据说，这就是传统的BFS!!
public class Solution { 
    public List<List<Integer>> levelOrder(TreeNode root) { 
        List<List<Integer>> outter=new ArrayList<List<Integer>>(); 
        List<Integer> inner=new LinkedList<Integer>(); 
        if(root==null)  return outter; 
        int curcount=1; 
        int nexcount=0; 
        Queue<TreeNode> queue=new LinkedList<TreeNode>(); 
        queue.add(root); 
        while(!queue.isEmpty()){ 
            TreeNode node=queue.poll(); 
            inner.add(node.val); 
            --curcount; 
            if(node.left!=null){ 
                queue.add(node.left); 
                ++nexcount; 
            } 
            if(node.right!=null){ 
                queue.add(node.right); 
                ++nexcount; 
            } 
            if(curcount==0){ 
                curcount=nexcount; 
                nexcount=0; 
                if(!inner.isEmpty()){ 
                    outter.add(inner); 
                    inner=new LinkedList<Integer>(); 
                } 
            } 
        } 
        return outter; 
    } 
}