var Component=(()=>{var h=Object.create;var n=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var v=Object.getOwnPropertyNames;var f=Object.getPrototypeOf,m=Object.prototype.hasOwnProperty;var g=(r,e)=>()=>(e||r((e={exports:{}}).exports,e),e.exports),T=(r,e)=>{for(var o in e)n(r,o,{get:e[o],enumerable:!0})},a=(r,e,o,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let l of v(e))!m.call(r,l)&&l!==o&&n(r,l,{get:()=>e[l],enumerable:!(i=p(e,l))||i.enumerable});return r};var N=(r,e,o)=>(o=r!=null?h(f(r)):{},a(e||!r||!r.__esModule?n(o,"default",{value:r,enumerable:!0}):o,r)),y=r=>a(n({},"__esModule",{value:!0}),r);var d=g((j,s)=>{s.exports=_jsx_runtime});var b={};T(b,{default:()=>c,frontmatter:()=>x});var t=N(d()),x={title:"102. Binary Tree Level Order Traversal",difficulty:"medium",tags:["Binary Tree","BFS","Queue"]};function u(r){let e={a:"a",br:"br",code:"code",h2:"h2",h3:"h3",p:"p",span:"span",strong:"strong",...r.components},{JavaCodeExecutor:o}=e;return o||w("JavaCodeExecutor",!0),(0,t.jsxs)(t.Fragment,{children:[(0,t.jsxs)(e.h2,{id:"problem",children:[(0,t.jsx)(e.a,{className:"anchor",href:"#problem",children:(0,t.jsx)(e.span,{className:"icon icon-link"})}),"Problem"]}),` `,(0,t.jsxs)(e.p,{children:["Given the ",(0,t.jsx)(e.code,{children:"root"})," of a binary tree, return the level order traversal of its nodes' values (i.e., from left to right, level by level)."]}),` `,(0,t.jsxs)(e.h2,{id:"explanation",children:[(0,t.jsx)(e.a,{className:"anchor",href:"#explanation",children:(0,t.jsx)(e.span,{className:"icon icon-link"})}),"Explanation"]}),` `,(0,t.jsxs)(e.h3,{id:"final-solution-bfs-with-queue",children:[(0,t.jsx)(e.a,{className:"anchor",href:"#final-solution-bfs-with-queue",children:(0,t.jsx)(e.span,{className:"icon icon-link"})}),"Final solution: BFS with queue"]}),` `,(0,t.jsxs)(e.p,{children:["I use a ",(0,t.jsx)(e.code,{children:"Queue"}),` to traverse the tree level by level. First, I handle the empty tree edge case by returning an empty list immediately. Then I start by adding the root node to the queue. The key insight is to process nodes in complete levels: before processing each level, I capture the current queue size, which tells me exactly how many nodes are in that level. I then loop that many times, polling each node, recording its value, and adding its children (left first, then right) to the queue for the next level. After processing all nodes in a level, I add that level's list to my result. This continues until the queue is empty, meaning I've visited every node exactly once. The BFS approach naturally produces the level-order traversal because the queue maintains the "next nodes to visit" in the correct left-to-right, level-by-level order.`]}),` `,(0,t.jsxs)(e.p,{children:[(0,t.jsx)(e.strong,{children:"Time:"})," O(n)",(0,t.jsx)(e.br,{}),` `,(0,t.jsx)(e.strong,{children:"Space:"})," O(n)"]}),` `,(0,t.jsxs)(e.h2,{id:"solution",children:[(0,t.jsx)(e.a,{className:"anchor",href:"#solution",children:(0,t.jsx)(e.span,{className:"icon icon-link"})}),"Solution"]}),` `,(0,t.jsx)(o,{initialCode:`class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int val) { this.val = val; } TreeNode(int val, TreeNode left, TreeNode right) { this.val = val; this.left = left; this.right = right; } } class Solution { public java.util.List> levelOrder(TreeNode root) { java.util.List> result = new java.util.ArrayList<>(); if (root == null) return result; java.util.Queue queue = new java.util.ArrayDeque<>(); queue.offer(root); while (!queue.isEmpty()) { int levelSize = queue.size(); java.util.List level = new java.util.ArrayList<>(); for (int i = 0; i < levelSize; i++) { TreeNode node = queue.poll(); level.add(node.val); if (node.left != null) queue.offer(node.left); if (node.right != null) queue.offer(node.right); } result.add(level); } return result; } }`,testCases:[{id:"Test 1",expectedOutput:"[[3], [9, 20], [15, 7]]",params:"root = [3, 9, 20, null, null, 15, 7]",call:`TreeNode root = new TreeNode(3); root.left = new TreeNode(9); root.right = new TreeNode(20); root.right.left = new TreeNode(15); root.right.right = new TreeNode(7); System.out.println(sol.levelOrder(root));`},{id:"Test 2",expectedOutput:"[[1]]",params:"root = [1]",call:`TreeNode root = new TreeNode(1); System.out.println(sol.levelOrder(root));`},{id:"Test 3",expectedOutput:"[]",params:"root = []",call:`TreeNode root = null; System.out.println(sol.levelOrder(root));`},{id:"Test 4",expectedOutput:"[[1], [2, 3], [4, 5]]",params:"root = [1, 2, 3, 4, 5]",call:`TreeNode root = new TreeNode(1); root.left = new TreeNode(2); root.right = new TreeNode(3); root.left.left = new TreeNode(4); root.left.right = new TreeNode(5); System.out.println(sol.levelOrder(root));`}]})]})}function c(r={}){let{wrapper:e}=r.components||{};return e?(0,t.jsx)(e,{...r,children:(0,t.jsx)(u,{...r})}):u(r)}function w(r,e){throw new Error("Expected "+(e?"component":"object")+" `"+r+"` to be defined: you likely forgot to import, pass, or provide it.")}return y(b);})(); ;return Component;

My LeetCode solutions

739. Daily Temperatures