【CT】LeetCode手撕—102. 二叉树的层序遍历

目录

  • 题目
  • 1-思路
  • [2- 实现](#2- 实现)
    • [⭐102. 二叉树的层序遍历------题解思路](#⭐102. 二叉树的层序遍历——题解思路)
  • [3- ACM实现](#3- ACM实现)
    • [3-1 二叉树构造](#3-1 二叉树构造)
    • [3-2 整体实现](#3-2 整体实现)

题目


1-思路

  • 1.借助队列 Queue ,每次利用 ①while 循环遍历当前层结点②将当前层结点的下层结点放入 Queue中
  • 2.每遍历一个结点,将值收集到 iterm 中,每一层遍历完,将结果存到 res

2- 实现

⭐102. 二叉树的层序遍历------题解思路

java 复制代码
class Solution {
    // 结果
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        if(root==null){
            return res;
        }
        queue.offer(root);

        while(!queue.isEmpty()){
            int len = queue.size();
            List<Integer> iterm = new ArrayList<>();
            while(len>0){
                TreeNode node = queue.poll();
                iterm.add(node.val);
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
                len--;
            }
            res.add(new ArrayList(iterm));
        }
        return res;
    }
}

3- ACM实现

3-1 二叉树构造

java 复制代码
public static TreeNode build(Integer[] nums){
    // 借助 queue 来实现二叉树构造
    Queue<TreeNode> queue = new LinkedList<>();
    TreeNode root = new TreeNode(nums[0]);
    queue.offer(root);
    int index = 1;
    while (!queue.isEmpty() && index < nums.length){
        TreeNode node = queue.poll();
        if(nums[index]!=null && index<nums.length){
            node.left = new TreeNode(nums[index]);
            queue.offer(node.left);
        }
        index++;
        if (nums[index]!=null && index<nums.length){
            node.right = new TreeNode(nums[index]);
            queue.offer(node.right);
        }
        index++;
    }
    return root;
}

3-2 整体实现

java 复制代码
public class levelTraversal {

    static class TreeNode{
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(){}
        TreeNode(int x){
            val = x;
        }
    }

    public static TreeNode build(Integer[] nums){
        // 借助 queue 来实现二叉树构造
        Queue<TreeNode> queue = new LinkedList<>();
        TreeNode root = new TreeNode(nums[0]);
        queue.offer(root);
        int index = 1;
        while (!queue.isEmpty() && index < nums.length){
            TreeNode node = queue.poll();
            if(nums[index]!=null && index<nums.length){
                node.left = new TreeNode(nums[index]);
                queue.offer(node.left);
            }
            index++;
            if (nums[index]!=null && index<nums.length){
                node.right = new TreeNode(nums[index]);
                queue.offer(node.right);
            }
            index++;
        }
        return root;
    }


    static List<List<Integer>> res = new ArrayList<>();
    public static List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        if(root==null){
            return res;
        }
        queue.offer(root);

        while(!queue.isEmpty()){
            int len = queue.size();
            List<Integer> iterm = new ArrayList<>();
            while(len>0){
                TreeNode node = queue.poll();
                iterm.add(node.val);
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
                len--;
            }
            res.add(new ArrayList(iterm));
        }
        return res;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入二叉树构造数组");
        String input = sc.nextLine();
        input = input.replace("[","");
        input = input.replace("]","");
        String[] parts = input.split(",");
        Integer[] nums = new Integer[parts.length];
        for(int i = 0 ; i <parts.length;i++){
            if(!parts[i].equals("null")){
                nums[i] = Integer.parseInt(parts[i]);
            }else{
                nums[i] = null;
            }
        }
        TreeNode root = build(nums);

        List<List<Integer>> forRes = levelOrder(root);
        for(List<Integer> i:forRes){
            System.out.println(i.toString());
        }
    }

}
相关推荐
2501_9248792611 分钟前
客流特征识别误报率↓76%!陌讯多模态时序融合算法在智慧零售的实战解析
大数据·人工智能·算法·目标检测·计算机视觉·视觉检测·零售
北京地铁1号线24 分钟前
广告推荐模型2:因子分解机(Factorization Machines, FM)
人工智能·算法·推荐算法
七十二小時1 小时前
力扣热题——前K个高频元素
数据结构·算法·leetcode
500佰1 小时前
AI手办,Gemini 2.5 Flash Image 可一键制作高一致性人物手办
算法
愚润求学2 小时前
【贪心算法】day3
c++·算法·leetcode·贪心算法
空白到白3 小时前
算法练习-合并两个有序数组
数据结构·python·算法
YuTaoShao3 小时前
【LeetCode 热题 100】75. 颜色分类——双指针
算法·leetcode·职场和发展
花开富贵ii5 小时前
代码随想录算法训练营四十九天|图论part07
java·数据结构·算法·图论·prim·kruscal
CoovallyAIHub5 小时前
无需ReID网络!FastTracker凭借几何与场景认知实现多目标跟踪新SOTA,助力智慧交通更轻更快
深度学习·算法·计算机视觉
CoovallyAIHub6 小时前
D‘RespNeT无人机图像分割数据集与YOLOv8-DRN模型,实时识别入口与障碍,助力灾后救援
深度学习·算法·计算机视觉