Binary Tree Level Order Traversal & Fibonacci Number

Author: GolubevDS

README.MD

@@ -30,4 +30,6 @@ Solving problems with LeetCode
 | [N-ary Tree Preorder Traversal](https://leetcode.com/problems/n-ary-tree-preorder-traversal/)                      | [Solution](https://github.com/GolubevDS/LeetCodePatterns/blob/main/solutions/preorder/preorder.js)                       | Easy       |
 | [First Bad Version](https://leetcode.com/problems/first-bad-version/)                                              | [Solution](https://github.com/GolubevDS/LeetCodePatterns/blob/main/solutions/findFirstBadVersion/findFirstBadVersion.js) | Easy       |
 | [Binary Search](https://leetcode.com/problems/binary-search/)                                                      | [Solution](https://github.com/GolubevDS/LeetCodePatterns/blob/main/solutions/binarySearch/binarySearch.js)               | Easy       |
-| [Linked List Cycle II](https://leetcode.com/problems/linked-list-cycle-ii/description/)                            | [Solution](https://github.com/GolubevDS/LeetCodePatterns/blob/main/solutions/detectCycle/detectCycle.js)                 | Medium     |
+| [Fibonacci Number](https://leetcode.com/problems/fibonacci-number/)                                                | [Solution](https://github.com/GolubevDS/LeetCodePatterns/blob/main/solutions/fib/fib.js)                                 | Easy       |
+| [Linked List Cycle II](https://leetcode.com/problems/linked-list-cycle-ii/)                                        | [Solution](https://github.com/GolubevDS/LeetCodePatterns/blob/main/solutions/detectCycle/detectCycle.js)                 | Medium     |
+| [Binary Tree Level Order Traversal](https://leetcode.com/problems/binary-tree-level-order-traversal/)              | [Solution](https://github.com/GolubevDS/LeetCodePatterns/blob/main/solutions/levelOrder/levelOrder.js)                   | Medium     |

helpers/treeNode.js

@@ -0,0 +1,7 @@
+function TreeNode(val, left, right) {
+	this.val = (val === undefined ? 0 : val);
+	this.left = (left === undefined ? null : left);
+	this.right = (right === undefined ? null : right);
+}
+
+module.exports = TreeNode;

package.json

@@ -1,4 +1,5 @@
 {
+  "type": "module",
   "devDependencies": {
     "jest": "^29.3.1"
   },

solutions/fib/README.MD

@@ -0,0 +1,10 @@
+## [509. Fibonacci Number](https://leetcode.com/problems/fibonacci-number/)
+
+The Fibonacci numbers, commonly denoted `F(n)` form a sequence, called the Fibonacci sequence, such that each number is the sum of the two preceding ones, starting from `0` and `1`. That is,
+
+```
+F(0) = 0, F(1) = 1
+F(n) = F(n - 1) + F(n - 2), for n > 1.
+```
+
+Given `n`, calculate `F(n)`.

solutions/fib/fib.js

@@ -0,0 +1,12 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+function fib(n) {
+	if (n === 0) return 0;
+	if (n === 1) return 1;
+
+	return fib(n - 1) + fib(n - 2);
+}
+
+module.exports = fib;

solutions/fib/fib.spec.js

@@ -3,6 +3,11 @@ declare class ListNode {
 	next: ListNode | null;
 	constructor(val: number);
 }
+declare class TreeNode {
+	val: number;
+	left: TreeNode | null;
+	right: TreeNode | null;
+}
 // @ts-ignore
 declare class Node {
 	val: number;

solutions/index.d.ts

@@ -0,0 +1,3 @@
+## [102. Binary Tree Level Order Traversal](https://leetcode.com/problems/binary-tree-level-order-traversal/)
+
+Given the `root` of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level).

solutions/levelOrder/README.MD

@@ -0,0 +1,28 @@
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+function levelOrder(root) {
+	if (!root) return [];
+
+	const result = [],
+	      queue  = [root];
+
+	while (queue.length > 0) {
+		const level = [];
+		const size = queue.length;
+
+		for (let i = 0; i < size; i++) {
+			const node = queue.shift();
+			level.push(node.val);
+			if (node.left) queue.push(node.left);
+			if (node.right) queue.push(node.right);
+		}
+
+		result.push(level);
+	}
+
+	return result;
+}
+
+module.exports = levelOrder;

solutions/levelOrder/levelOrder.js

@@ -0,0 +1,28 @@
+const TreeNode = require('../../helpers/treeNode');
+const levelOrder = require('./levelOrder');
+
+describe('Binary Tree Level Order Traversal', () => {
+	test('returns an empty array for empty input', () => {
+		const root = null;
+		const expected = [];
+		expect(levelOrder(root)).toEqual(expected);
+	});
+
+	test('returns the correct result for a tree with one node', () => {
+		const root = new TreeNode(1);
+		const expected = [[1]];
+		expect(levelOrder(root)).toEqual(expected);
+	});
+
+	test('returns the correct result for a tree with multiple levels', () => {
+		const root = new TreeNode(3,
+			new TreeNode(9),
+			new TreeNode(20,
+				new TreeNode(15),
+				new TreeNode(7),
+			),
+		);
+		const expected = [[3], [9, 20], [15, 7]];
+		expect(levelOrder(root)).toEqual(expected);
+	});
+});