LeetCode-in-TypeScript · javadev · Apr 15, 2025 · Apr 15, 2025
diff --git a/README.md b/README.md
@@ -236,6 +236,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0053 |[Maximum Subarray](src/main/ts/g0001_0100/s0053_maximum_subarray/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Divide_and_Conquer, Big_O_Time_O(n)_Space_O(1) | 0 | 100.00
+| 0918 |[Maximum Sum Circular Subarray](src/main/ts/g0901_1000/s0918_maximum_sum_circular_subarray/solution.ts)| Medium | Array, Dynamic_Programming, Divide_and_Conquer, Queue, Monotonic_Queue, Medium, Array, Dynamic_Programming, Divide_and_Conquer, Queue, Monotonic_Queue | 2 | 91.04
 
 #### Day 6
 
@@ -1111,6 +1112,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 | 0228 |[Summary Ranges](src/main/ts/g0201_0300/s0228_summary_ranges/solution.ts)| Easy | Array | 0 | 100.00
 | 0056 |[Merge Intervals](src/main/ts/g0001_0100/s0056_merge_intervals/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Big_O_Time_O(n_log_n)_Space_O(n) | 7 | 87.99
 | 0057 |[Insert Interval](src/main/ts/g0001_0100/s0057_insert_interval/solution.ts)| Medium | Array | 0 | 100.00
+| 0452 |[Minimum Number of Arrows to Burst Balloons](src/main/ts/g0401_0500/s0452_minimum_number_of_arrows_to_burst_balloons/solution.ts)| Medium | Array, Sorting, Greedy | 75 | 98.54
 
 #### Top Interview 150 Stack
 
@@ -1161,13 +1163,15 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0199 |[Binary Tree Right Side View](src/main/ts/g0101_0200/s0199_binary_tree_right_side_view/solution.ts)| Medium | Top_100_Liked_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 0 | 100.00
+| 0637 |[Average of Levels in Binary Tree](src/main/ts/g0601_0700/s0637_average_of_levels_in_binary_tree/solution.ts)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 0 | 100.00
 | 0102 |[Binary Tree Level Order Traversal](src/main/ts/g0101_0200/s0102_binary_tree_level_order_traversal/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Breadth_First_Search, Tree, Binary_Tree, Big_O_Time_O(N)_Space_O(N) | 0 | 100.00
 | 0103 |[Binary Tree Zigzag Level Order Traversal](src/main/ts/g0101_0200/s0103_binary_tree_zigzag_level_order_traversal/solution.ts)| Medium | Top_Interview_Questions, Breadth_First_Search, Tree, Binary_Tree | 0 | 100.00
 
 #### Top Interview 150 Binary Search Tree
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0530 |[Minimum Absolute Difference in BST](src/main/ts/g0501_0600/s0530_minimum_absolute_difference_in_bst/solution.ts)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 0 | 100.00
 | 0230 |[Kth Smallest Element in a BST](src/main/ts/g0201_0300/s0230_kth_smallest_element_in_a_bst/solution.ts)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Big_O_Time_O(n)_Space_O(n) | 0 | 100.00
 | 0098 |[Validate Binary Search Tree](src/main/ts/g0001_0100/s0098_validate_binary_search_tree/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Big_O_Time_O(N)_Space_O(log(N)) | 0 | 100.00
 
@@ -1183,6 +1187,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0909 |[Snakes and Ladders](src/main/ts/g0901_1000/s0909_snakes_and_ladders/solution.ts)| Medium | Array, Breadth_First_Search, Matrix | 5 | 98.27
 | 0433 |[Minimum Genetic Mutation](src/main/ts/g0401_0500/s0433_minimum_genetic_mutation/solution.ts)| Medium | String, Hash_Table, Breadth_First_Search | 0 | 100.00
 | 0127 |[Word Ladder](src/main/ts/g0101_0200/s0127_word_ladder/solution.ts)| Hard | Top_Interview_Questions, String, Hash_Table, Breadth_First_Search | 41 | 95.63
 
@@ -1220,6 +1225,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0053 |[Maximum Subarray](src/main/ts/g0001_0100/s0053_maximum_subarray/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Divide_and_Conquer, Big_O_Time_O(n)_Space_O(1) | 0 | 100.00
+| 0918 |[Maximum Sum Circular Subarray](src/main/ts/g0901_1000/s0918_maximum_sum_circular_subarray/solution.ts)| Medium | Array, Dynamic_Programming, Divide_and_Conquer, Queue, Monotonic_Queue, Medium, Array, Dynamic_Programming, Divide_and_Conquer, Queue, Monotonic_Queue | 2 | 91.04
 
 #### Top Interview 150 Binary Search
 
@@ -1238,6 +1244,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0215 |[Kth Largest Element in an Array](src/main/ts/g0201_0300/s0215_kth_largest_element_in_an_array/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Heap_Priority_Queue, Divide_and_Conquer, Quickselect, Big_O_Time_O(n\*log(n))_Space_O(log(n)) | 4 | 99.64
+| 0502 |[IPO](src/main/ts/g0501_0600/s0502_ipo/solution.ts)| Hard | Array, Sorting, Greedy, Heap_Priority_Queue | 193 | 89.19
 | 0373 |[Find K Pairs with Smallest Sums](src/main/ts/g0301_0400/s0373_find_k_pairs_with_smallest_sums/solution.ts)| Medium | Array, Heap_Priority_Queue | 42 | 85.15
 | 0295 |[Find Median from Data Stream](src/main/ts/g0201_0300/s0295_find_median_from_data_stream/solution.ts)| Hard | Top_100_Liked_Questions, Sorting, Two_Pointers, Design, Heap_Priority_Queue, Data_Stream, Big_O_Time_O(n\*log_n)_Space_O(n) | 106 | 92.31
 
@@ -1743,12 +1750,18 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
 | 1143 |[Longest Common Subsequence](src/main/ts/g1101_1200/s1143_longest_common_subsequence/solution.ts)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_17_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming, Big_O_Time_O(n\*m)_Space_O(n\*m) | 50 | 69.40
+| 0918 |[Maximum Sum Circular Subarray](src/main/ts/g0901_1000/s0918_maximum_sum_circular_subarray/solution.ts)| Medium | Array, Dynamic_Programming, Divide_and_Conquer, Queue, Monotonic_Queue, Medium, Array, Dynamic_Programming, Divide_and_Conquer, Queue, Monotonic_Queue, Dynamic_Programming_I_Day_5, Top_Interview_150_Kadane's_Algorithm | 2 | 91.04
+| 0909 |[Snakes and Ladders](src/main/ts/g0901_1000/s0909_snakes_and_ladders/solution.ts)| Medium | Array, Breadth_First_Search, Matrix, Top_Interview_150_Graph_BFS | 5 | 98.27
 | 0763 |[Partition Labels](src/main/ts/g0701_0800/s0763_partition_labels/solution.ts)| Medium | String, Hash_Table, Greedy, Two_Pointers, Data_Structure_II_Day_7_String, Big_O_Time_O(n)_Space_O(1) | 4 | 86.89
 | 0739 |[Daily Temperatures](src/main/ts/g0701_0800/s0739_daily_temperatures/solution.ts)| Medium | Top_100_Liked_Questions, Array, Stack, Monotonic_Stack, Programming_Skills_II_Day_6, Big_O_Time_O(n)_Space_O(n) | 18 | 80.57
 | 0647 |[Palindromic Substrings](src/main/ts/g0601_0700/s0647_palindromic_substrings/solution.ts)| Medium | String, Dynamic_Programming, Big_O_Time_O(n^2)_Space_O(n) | 5 | 100.00
+| 0637 |[Average of Levels in Binary Tree](src/main/ts/g0601_0700/s0637_average_of_levels_in_binary_tree/solution.ts)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Top_Interview_150_Binary_Tree_BFS | 0 | 100.00
 | 0560 |[Subarray Sum Equals K](src/main/ts/g0501_0600/s0560_subarray_sum_equals_k/solution.ts)| Medium | Top_100_Liked_Questions, Array, Hash_Table, Prefix_Sum, Data_Structure_II_Day_5_Array, Big_O_Time_O(n)_Space_O(n) | 14 | 87.34
 | 0543 |[Diameter of Binary Tree](src/main/ts/g0501_0600/s0543_diameter_of_binary_tree/solution.ts)| Easy | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree, Udemy_Tree_Stack_Queue, Big_O_Time_O(n)_Space_O(n) | 1 | 87.16
+| 0530 |[Minimum Absolute Difference in BST](src/main/ts/g0501_0600/s0530_minimum_absolute_difference_in_bst/solution.ts)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Top_Interview_150_Binary_Search_Tree | 0 | 100.00
+| 0502 |[IPO](src/main/ts/g0501_0600/s0502_ipo/solution.ts)| Hard | Array, Sorting, Greedy, Heap_Priority_Queue, Top_Interview_150_Heap | 193 | 89.19
 | 0494 |[Target Sum](src/main/ts/g0401_0500/s0494_target_sum/solution.ts)| Medium | Array, Dynamic_Programming, Backtracking, Big_O_Time_O(n\*(sum+s))_Space_O(n\*(sum+s)) | 24 | 83.43
+| 0452 |[Minimum Number of Arrows to Burst Balloons](src/main/ts/g0401_0500/s0452_minimum_number_of_arrows_to_burst_balloons/solution.ts)| Medium | Array, Sorting, Greedy, Top_Interview_150_Intervals | 75 | 98.54
 | 0438 |[Find All Anagrams in a String](src/main/ts/g0401_0500/s0438_find_all_anagrams_in_a_string/solution.ts)| Medium | Top_100_Liked_Questions, String, Hash_Table, Sliding_Window, Algorithm_II_Day_5_Sliding_Window, Programming_Skills_II_Day_12, Level_1_Day_12_Sliding_Window/Two_Pointer, Big_O_Time_O(n+m)_Space_O(1) | 8 | 97.80
 | 0437 |[Path Sum III](src/main/ts/g0401_0500/s0437_path_sum_iii/solution.ts)| Medium | Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree, Big_O_Time_O(n)_Space_O(n) | 3 | 86.41
 | 0433 |[Minimum Genetic Mutation](src/main/ts/g0401_0500/s0433_minimum_genetic_mutation/solution.ts)| Medium | String, Hash_Table, Breadth_First_Search, Graph_Theory_I_Day_12_Breadth_First_Search, Top_Interview_150_Graph_BFS | 0 | 100.00

diff --git a/src/main/ts/g0401_0500/s0452_minimum_number_of_arrows_to_burst_balloons/readme.md b/src/main/ts/g0401_0500/s0452_minimum_number_of_arrows_to_burst_balloons/readme.md
@@ -0,0 +1,47 @@
+452\. Minimum Number of Arrows to Burst Balloons
+
+Medium
+
+There are some spherical balloons taped onto a flat wall that represents the XY-plane. The balloons are represented as a 2D integer array `points` where <code>points[i] = [x<sub>start</sub>, x<sub>end</sub>]</code> denotes a balloon whose **horizontal diameter** stretches between <code>x<sub>start</sub></code> and <code>x<sub>end</sub></code>. You do not know the exact y-coordinates of the balloons.
+
+Arrows can be shot up **directly vertically** (in the positive y-direction) from different points along the x-axis. A balloon with <code>x<sub>start</sub></code> and <code>x<sub>end</sub></code> is **burst** by an arrow shot at `x` if <code>x<sub>start</sub> <= x <= x<sub>end</sub></code>. There is **no limit** to the number of arrows that can be shot. A shot arrow keeps traveling up infinitely, bursting any balloons in its path.
+
+Given the array `points`, return _the **minimum** number of arrows that must be shot to burst all balloons_.
+
+**Example 1:**
+
+**Input:** points = [[10,16],[2,8],[1,6],[7,12]]
+
+**Output:** 2
+
+**Explanation:** The balloons can be burst by 2 arrows: 
+
+- Shoot an arrow at x = 6, bursting the balloons [2,8] and [1,6]. 
+
+- Shoot an arrow at x = 11, bursting the balloons [10,16] and [7,12].
+
+**Example 2:**
+
+**Input:** points = [[1,2],[3,4],[5,6],[7,8]]
+
+**Output:** 4
+
+**Explanation:** One arrow needs to be shot for each balloon for a total of 4 arrows.
+
+**Example 3:**
+
+**Input:** points = [[1,2],[2,3],[3,4],[4,5]]
+
+**Output:** 2
+
+**Explanation:** The balloons can be burst by 2 arrows: 
+
+- Shoot an arrow at x = 2, bursting the balloons [1,2] and [2,3]. 
+
+- Shoot an arrow at x = 4, bursting the balloons [3,4] and [4,5].
+
+**Constraints:**
+
+*   <code>1 <= points.length <= 10<sup>5</sup></code>
+*   `points[i].length == 2`
+*   <code>-2<sup>31</sup> <= x<sub>start</sub> < x<sub>end</sub> <= 2<sup>31</sup> - 1</code>
diff --git a/src/main/ts/g0401_0500/s0452_minimum_number_of_arrows_to_burst_balloons/solution.ts b/src/main/ts/g0401_0500/s0452_minimum_number_of_arrows_to_burst_balloons/solution.ts
@@ -0,0 +1,20 @@
+// #Medium #Array #Sorting #Greedy #Top_Interview_150_Intervals
+// #2025_04_15_Time_75_ms_(98.54%)_Space_79.44_MB_(62.20%)
+
+function findMinArrowShots(points: number[][]): number {
+    if (points.length === 0) {
+        return 0
+    }
+    points.sort((a, b) => a[1] - b[1])
+    let minArrows = 1
+    let end = points[0][1]
+    for (let i = 1; i < points.length; i++) {
+        if (points[i][0] > end) {
+            minArrows++
+            end = points[i][1]
+        }
+    }
+    return minArrows
+}
+
+export { findMinArrowShots }
diff --git a/src/main/ts/g0501_0600/s0502_ipo/readme.md b/src/main/ts/g0501_0600/s0502_ipo/readme.md
@@ -0,0 +1,47 @@
+502\. IPO
+
+Hard
+
+Suppose LeetCode will start its **IPO** soon. In order to sell a good price of its shares to Venture Capital, LeetCode would like to work on some projects to increase its capital before the **IPO**. Since it has limited resources, it can only finish at most `k` distinct projects before the **IPO**. Help LeetCode design the best way to maximize its total capital after finishing at most `k` distinct projects.
+
+You are given `n` projects where the <code>i<sup>th</sup></code> project has a pure profit `profits[i]` and a minimum capital of `capital[i]` is needed to start it.
+
+Initially, you have `w` capital. When you finish a project, you will obtain its pure profit and the profit will be added to your total capital.
+
+Pick a list of **at most** `k` distinct projects from given projects to **maximize your final capital**, and return _the final maximized capital_.
+
+The answer is guaranteed to fit in a 32-bit signed integer.
+
+**Example 1:**
+
+**Input:** k = 2, w = 0, profits = [1,2,3], capital = [0,1,1]
+
+**Output:** 4
+
+**Explanation:** 
+
+Since your initial capital is 0, you can only start the project indexed 0. 
+
+After finishing it you will obtain profit 1 and your capital becomes 1. 
+
+With capital 1, you can either start the project indexed 1 or the project indexed 2. 
+
+Since you can choose at most 2 projects, you need to finish the project indexed 2 to get the maximum capital. 
+
+Therefore, output the final maximized capital, which is 0 + 1 + 3 = 4.
+
+**Example 2:**
+
+**Input:** k = 3, w = 0, profits = [1,2,3], capital = [0,1,2]
+
+**Output:** 6
+
+**Constraints:**
+
+*   <code>1 <= k <= 10<sup>5</sup></code>
+*   <code>0 <= w <= 10<sup>9</sup></code>
+*   `n == profits.length`
+*   `n == capital.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>0 <= profits[i] <= 10<sup>4</sup></code>
+*   <code>0 <= capital[i] <= 10<sup>9</sup></code>
diff --git a/src/main/ts/g0501_0600/s0502_ipo/solution.ts b/src/main/ts/g0501_0600/s0502_ipo/solution.ts
@@ -0,0 +1,86 @@
+// #Hard #Array #Sorting #Greedy #Heap_Priority_Queue #Top_Interview_150_Heap
+// #2025_04_15_Time_193_ms_(89.19%)_Space_102.47_MB_(8.11%)
+
+class MaxHeap {
+    private heap: number[];
+
+    constructor() {
+        this.heap = [];
+    }
+
+    push(value: number) {
+        this.heap.push(value);
+        this.heapifyUp();
+    }
+
+    pop(): number | undefined {
+        if (this.heap.length === 0) {
+            return undefined;
+        }
+        if (this.heap.length === 1) {
+            return this.heap.pop();
+        }
+        const max = this.heap[0];
+        this.heap[0] = this.heap.pop()!;
+        this.heapifyDown();
+        return max;
+    }
+
+    isEmpty(): boolean {
+        return this.heap.length === 0;
+    }
+
+    private heapifyUp() {
+        let index = this.heap.length - 1;
+        while (index > 0) {
+            let parentIndex = Math.floor((index - 1) / 2);
+            if (this.heap[parentIndex] >= this.heap[index]) {
+                break;
+            }
+            [this.heap[parentIndex], this.heap[index]] = [this.heap[index], this.heap[parentIndex]];
+            index = parentIndex;
+        }
+    }
+
+    private heapifyDown() {
+        let index = 0;
+        while (true) {
+            let left = 2 * index + 1;
+            let right = 2 * index + 2;
+            let largest = index;
+            if (left < this.heap.length && this.heap[left] > this.heap[largest]) {
+                largest = left;
+            }
+            if (right < this.heap.length && this.heap[right] > this.heap[largest]) {
+                largest = right;
+            }
+            if (largest === index) break;
+            [this.heap[index], this.heap[largest]] = [this.heap[largest], this.heap[index]];
+            index = largest;
+        }
+    }
+}
+
+function findMaximizedCapital(k: number, w: number, profits: number[], capital: number[]): number {
+    let projects: [number, number][] = [];
+    const n = profits.length;
+    for (let i = 0; i < n; i++) {
+        projects.push([capital[i], profits[i]]);
+    }
+    projects.sort((a, b) => a[0] - b[0]);
+    const maxHeap = new MaxHeap();
+    let i = 0;
+    while (k--) {
+        while (i < n && projects[i][0] <= w) {
+            maxHeap.push(projects[i][1]);
+            i++;
+        }
+        if (maxHeap.isEmpty()) {
+            break;
+        }
+        w += maxHeap.pop()!;
+    }
+    return w;
+}
+
+export { findMaximizedCapital }
diff --git a/src/main/ts/g0501_0600/s0530_minimum_absolute_difference_in_bst/readme.md b/src/main/ts/g0501_0600/s0530_minimum_absolute_difference_in_bst/readme.md
@@ -0,0 +1,28 @@
+530\. Minimum Absolute Difference in BST
+
+Easy
+
+Given the `root` of a Binary Search Tree (BST), return _the minimum absolute difference between the values of any two different nodes in the tree_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/05/bst1.jpg)
+
+**Input:** root = [4,2,6,1,3]
+
+**Output:** 1
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/05/bst2.jpg)
+
+**Input:** root = [1,0,48,null,null,12,49]
+
+**Output:** 1
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[2, 10<sup>4</sup>]</code>.
+*   <code>0 <= Node.val <= 10<sup>5</sup></code>
+
+**Note:** This question is the same as 783: [https://leetcode.com/problems/minimum-distance-between-bst-nodes/](https://leetcode.com/problems/minimum-distance-between-bst-nodes/)
diff --git a/src/main/ts/g0501_0600/s0530_minimum_absolute_difference_in_bst/solution.ts b/src/main/ts/g0501_0600/s0530_minimum_absolute_difference_in_bst/solution.ts
@@ -0,0 +1,37 @@
+// #Easy #Depth_First_Search #Breadth_First_Search #Tree #Binary_Tree #Binary_Search_Tree
+// #Top_Interview_150_Binary_Search_Tree #2025_04_15_Time_0_ms_(100.00%)_Space_61.15_MB_(83.13%)
+
+import { TreeNode } from '../../com_github_leetcode/treenode'
+
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+function getMinimumDifference(root: TreeNode | null): number {
+    let ans = Number.MAX_SAFE_INTEGER
+    let prev: number | null = null
+    function dfs(node: TreeNode | null) {
+        if (!node) {
+            return
+        }
+        dfs(node.left)
+        if (prev !== null) {
+            ans = Math.min(ans, Math.abs(node.val - prev))
+        }
+        prev = node.val
+        dfs(node.right)
+    }
+    dfs(root)
+    return ans
+}
+
+export { getMinimumDifference }
diff --git a/src/main/ts/g0601_0700/s0637_average_of_levels_in_binary_tree/readme.md b/src/main/ts/g0601_0700/s0637_average_of_levels_in_binary_tree/readme.md
@@ -0,0 +1,26 @@
+637\. Average of Levels in Binary Tree
+
+Easy
+
+Given the `root` of a binary tree, return _the average value of the nodes on each level in the form of an array_. Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/09/avg1-tree.jpg)
+
+**Input:** root = [3,9,20,null,null,15,7]
+
+**Output:** [3.00000,14.50000,11.00000] Explanation: The average value of nodes on level 0 is 3, on level 1 is 14.5, and on level 2 is 11. Hence return [3, 14.5, 11].
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/09/avg2-tree.jpg)
+
+**Input:** root = [3,9,20,15,7]
+
+**Output:** [3.00000,14.50000,11.00000]
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.
+*   <code>-2<sup>31</sup> <= Node.val <= 2<sup>31</sup> - 1</code>