【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());
        }
    }

}
相关推荐
AC使者1 分钟前
5820 丰富的周日生活
数据结构·算法
cwj&xyp30 分钟前
Python(二)str、list、tuple、dict、set
前端·python·算法
xiaoshiguang35 小时前
LeetCode:222.完全二叉树节点的数量
算法·leetcode
爱吃西瓜的小菜鸡5 小时前
【C语言】判断回文
c语言·学习·算法
别NULL5 小时前
机试题——疯长的草
数据结构·c++·算法
TT哇5 小时前
*【每日一题 提高题】[蓝桥杯 2022 国 A] 选素数
java·算法·蓝桥杯
yuanbenshidiaos6 小时前
C++----------函数的调用机制
java·c++·算法
唐叔在学习6 小时前
【唐叔学算法】第21天:超越比较-计数排序、桶排序与基数排序的Java实践及性能剖析
数据结构·算法·排序算法
ALISHENGYA7 小时前
全国青少年信息学奥林匹克竞赛(信奥赛)备考实战之分支结构(switch语句)
数据结构·算法
chengooooooo7 小时前
代码随想录训练营第二十七天| 贪心理论基础 455.分发饼干 376. 摆动序列 53. 最大子序和
算法·leetcode·职场和发展