{"title":"JavaScript Crash Course for DSA","description":"","content":"This chapter is a focused crash course on the JavaScript features that come up repeatedly in DSA and coding interviews. Instead of covering the entire language, we will concentrate only on the parts that matter for solving problems efficiently in interviews.\n\n---\n\n# No Imports Needed\n\nJavaScript does not require any imports for DSA work. Every data structure and utility function you need is globally available.\n\nOn LeetCode, your solution is a function. There is no class wrapping, no `import` statements, no `#include` directives. You write your function and submit. This is one of the reasons JavaScript is popular for coding interviews: zero boilerplate.\n\nJavaScript ships with these built-in types:\n\n\n| Built-in | What It Provides | DSA Use Case |\n|----------|-----------------|--------------|\n| `Array` | Dynamic array with rich methods | Primary data structure for everything |\n| `Map` | Hash map with any key type | Frequency counting, O(1) lookups |\n| `Set` | Hash set with any value type | Visited tracking, deduplication |\n| `Object` | Key-value pairs (string keys) | Simple frequency maps |\n| `Math` | `max`, `min`, `floor`, `ceil`, `abs`, `sqrt`, `log2` | Utility calculations |\n| `JSON` | `stringify`, `parse` | Deep copy, composite keys |\n| `Infinity` / `-Infinity` | Global sentinel values | Min/max initialization |\n\n\nBut JavaScript also has notable gaps. These are data structures common in DSA that have no built-in equivalent:\n\n\n| Not Built-in | What You Must Do |\n|--------------|------------------|\n| Queue | Use array with pointer, or linked list |\n| Deque | Use array (limited), or custom class |\n| PriorityQueue | Implement a min-heap yourself |\n| TreeMap / TreeSet | Sorted array + binary search (limited) |\n\n\nWe will cover workarounds for each of these missing structures later in this chapter. For now, know that what JavaScript gives you out of the box is clean, concise, and fast to write.\n\n---\n\n# Variables, Types, and the Number Type Trap\n\nJavaScript is dynamically typed. You do not declare types, you assign values and the engine figures it out:\n\n\n```javascript\nlet count = 0; // number\nconst ratio = 3.14; // number (same type as count!)\nconst name = \"hello\"; // string\nlet found = true; // boolean\nconst nothing = null; // null\nlet missing; // undefined\n```\n\n\nFor variable declarations, follow one rule: **use **`const`** by default, **`let`** when you need to reassign, never **`var`**.** The `var` keyword has function scope (not block scope), which leads to subtle bugs in loops and conditionals. Both `let` and `const` are block-scoped, which is what you expect coming from any other language.\n\n\n```javascript\n// var leaks out of blocks (dangerous)\nfor (var i = 0; i < 5; i++) { }\nconsole.log(i); // 5 (still accessible!)\n\n// let stays in its block (safe)\nfor (let j = 0; j < 5; j++) { }\nconsole.log(j); // ReferenceError: j is not defined\n```\n\n\nFor DSA, a small set of types covers most problems:\n\n\n| Type | Example | DSA Use Case |\n|------|---------|--------------|\n| `number` | `42`, `3.14`, `Infinity` | Everything numeric (no separate int/float!) |\n| `string` | `\"hello\"` | Immutable character sequences |\n| `boolean` | `true`, `false` | Visited arrays, flags |\n| `null` | `null` | Intentional absence (tree/linked list terminators) |\n| `undefined` | `undefined` | Uninitialized variables, missing properties |\n| `bigint` | `42n` | Values exceeding 2^53 - 1 (rare in DSA) |\n\n\nJavaScript has no integer type. Every number is an IEEE 754 64-bit floating-point double. The number `42` and the number `42.0` are the same value, the same type, stored the same way.\n\nThis has three critical implications for DSA:\n\n**1. Division always produces a float.** In JavaScript, `7 / 2` gives `3.5`, not `3`. You must explicitly truncate when you need an integer:\n\n\n```javascript\n// Integer division in JavaScript\nMath.floor(7 / 2); // 3 (rounds toward negative infinity)\nMath.trunc(7 / 2); // 3 (rounds toward zero)\nMath.ceil(7 / 2); // 4 (rounds toward positive infinity)\n\n// For positive numbers, floor and trunc are the same\n// For negative numbers, they differ:\nMath.floor(-7 / 2); // -4 (rounds down)\nMath.trunc(-7 / 2); // -3 (rounds toward zero)\n```\n\n\n**2. Integer precision is limited to 2^53 - 1.** The `Number.MAX_SAFE_INTEGER` is 9,007,199,254,740,991. Beyond this, integer arithmetic loses precision without warning:\n\n\n```javascript\nconsole.log(9007199254740992 === 9007199254740993); // true! (both round to the same float)\n```\n\n\nFor most DSA problems where constraints are up to 10^9, this is not an issue. But for problems involving large prefix sums or multiplication of large values, be aware. If you need arbitrary precision, use `BigInt`:\n\n\n```javascript\nconst big = 9007199254740993n; // note the 'n' suffix\nconst result = big * 2n; // BigInt arithmetic\n// Cannot mix: big + 1 throws TypeError. Must use big + 1n\n```\n\n\n**3. Binary search midpoint does not overflow, but needs floor.** JavaScript numbers safely hold sums up to 2^53, so `(left + right)` will not overflow. But you need `Math.floor` because division produces a float:\n\n\n```javascript\n// WRONG: produces a float when left + right is odd\nconst mid = (left + right) / 2;\n\n// CORRECT: floor to get integer index\nconst mid = Math.floor((left + right) / 2);\n\n// Also correct, though unnecessary since JS uses 64-bit doubles\nconst mid = left + Math.floor((right - left) / 2);\n```\n\n\nWhen a problem says \"return an integer,\" you still return a `number` in JavaScript. But always make sure your arithmetic produces an integer result. Using `Math.floor` in binary search and division is a habit that prevents bugs.\n\nThe **ternary operator** works the same as in other languages:\n\n\n```javascript\nconst result = (a > b) ? a : b; // Same as Math.max(a, b)\nconst label = (count === 1) ? \"item\" : \"items\";\n```\n\n\nThe `typeof` operator has these quirks:\n\n\n```javascript\ntypeof 42 // \"number\"\ntypeof \"hello\" // \"string\"\ntypeof true // \"boolean\"\ntypeof undefined // \"undefined\"\ntypeof null // \"object\" // <-- Classic JS bug! null is NOT an object\ntypeof [] // \"object\" // Arrays are objects\ntypeof {} // \"object\"\nArray.isArray([]) // true // The correct way to check for arrays\n```\n\n\nThe `typeof null === \"object\"` is a bug from the first version of JavaScript in 1995 that was never fixed because it would break existing code. You will not encounter this in DSA problems, but it sometimes shows up in trivia questions.\n\n---\n\n# Operators and Control Flow\n\nMost operators work as you would expect, but a few deserve special attention for DSA.\n\n### Strict Equality\n\n**Always use **`===`** and **`!==`** in JavaScript.** The `==` operator performs type coercion, which creates surprising results:\n\n\n```javascript\n0 == \"\" // true (empty string coerces to 0)\n0 == false // true (false coerces to 0)\nnull == undefined // true (special coercion rule)\n\"5\" == 5 // true (string coerces to number)\n[] == false // true (array coerces to 0)\n\n// With ===, none of these are true\n0 === \"\" // false\n0 === false // false\nnull === undefined // false\n\"5\" === 5 // false\n```\n\n\nThere is one acceptable use of `==`: checking for both `null` and `undefined` in a single comparison. `val == null` is `true` when `val` is either `null` or `undefined`, and `false` for everything else. Either `val === null || val === undefined` or `val == null` is acceptable; just pick one and be consistent.\n\n### Modular Arithmetic\n\nThe `%` operator appears in hashing, cyclic array problems, and math-heavy questions. JavaScript's `%` can return negative values for negative operands: `-7 % 3` gives `-1`, not `2`. To guarantee a positive result:\n\n\n```javascript\n((n % m) + m) % m // Always non-negative\n```\n\n\nMany problems ask you to return the result \"modulo 10^9 + 7\" to prevent large outputs. This is a standard pattern:\n\n\n```javascript\nconst MOD = 1_000_000_007; // Underscores for readability (ES2021)\n\nlet result = 0;\nfor (let i = 0; i < n; i++) {\n result = (result + values[i]) % MOD;\n}\nreturn result;\n```\n\n\n### Bitwise Operators\n\nA JavaScript-specific gotcha: **bitwise operators convert operands to 32-bit signed integers.** This means:\n\n\n```javascript\n1 << 31 // -2147483648 (negative! bit 31 is the sign bit)\n1 << 32 // 1 (wraps around, NOT 2^32)\n```\n\n\nThis limits bitmask problems in JavaScript to **31 bits**. For most DSA problems, 31 bits (representing sets of up to 31 elements) is sufficient. But be aware of this if you are porting bitmask DP solutions from other languages.\n\nThe key bitwise operators:\n\n\n| Operator | Symbol | DSA Use |\n|----------|--------|---------|\n| AND | `&` | Masking, checking if bit is set: `(n & (1 << i)) !== 0` |\n| OR | `\\|` | Setting bits: `n \\| (1 << i)` |\n| XOR | `^` | Finding unique elements, toggling bits |\n| NOT | `~` | Bit inversion |\n| Left shift | `<<` | Multiply by powers of 2: `1 << n` equals 2^n (up to n=30) |\n| Right shift | `>>` | Divide by powers of 2 (preserves sign) |\n| Unsigned right shift | `>>>` | Divide by powers of 2 (fills with 0) |\n\n\nCommon bit manipulation patterns:\n\n\n```javascript\n// XOR trick: find the number that appears once (all others appear twice)\nlet single = 0;\nfor (const num of nums) {\n single ^= num; // XOR cancels out duplicates\n}\n\n// Check if bit i is set\nconst isSet = (mask & (1 << i)) !== 0;\n\n// Set bit i\nmask = mask | (1 << i);\n\n// Clear bit i\nmask = mask & ~(1 << i);\n\n// Toggle bit i\nmask = mask ^ (1 << i);\n\n// Count set bits\nfunction popcount(n) {\n let count = 0;\n while (n) {\n count += n & 1;\n n >>>= 1; // unsigned right shift to handle negative numbers\n }\n return count;\n}\n// Or use the string trick: n.toString(2).split('').filter(b => b === '1').length\n```\n\n\n### Control Flow\n\nJavaScript offers several loop forms. Use each where it fits:\n\n\n```javascript\n// Index-based for (most common in DSA)\nfor (let i = 0; i < nums.length; i++) {\n // access nums[i]\n}\n\n// Backward iteration\nfor (let i = n - 1; i >= 0; i--) {\n // process in reverse\n}\n\n// for...of (iterates values, the correct way to iterate arrays)\nfor (const num of nums) {\n // no index access, just values\n}\n\n// while (two pointers, linked list traversal)\nwhile (left < right) {\n // process\n}\n```\n\n\n**Warning:** Never use `for...in` on arrays. It iterates over string keys (including inherited prototype properties), not values:\n\n\n```javascript\n// WRONG: for...in on arrays\nconst nums = [10, 20, 30];\nfor (const i in nums) {\n console.log(typeof i); // \"string\"! i is \"0\", \"1\", \"2\" (not 0, 1, 2)\n}\n\n// CORRECT: for...of for values, for loop for indices\nfor (const num of nums) { /* values */ }\nfor (let i = 0; i < nums.length; i++) { /* index + value */ }\n```\n\n\n### Short-Circuit Evaluation and Modern Operators\n\nJavaScript has two operators that are useful for DSA:\n\n**Nullish coalescing (**`??`**):** Returns the right side only if the left is `null` or `undefined`:\n\n\n```javascript\nconst count = map.get(key) ?? 0; // 0 only if get returns null/undefined\n```\n\n\n**Optional chaining (**`?.`**):** Short-circuits to `undefined` if any part is `null` or `undefined`:\n\n\n```javascript\nconst val = node?.left?.val; // undefined if node or node.left is null/undefined\n```\n\n\nThe `??` operator is safer than `||` for default values. `map.get(key) || 0` would incorrectly treat a stored `0` as missing and return `0` from the right side. The `??` operator only replaces `null` and `undefined`, preserving legitimate falsy values like `0`, `\"\"`, and `false`.\n\n---\n\n# Functions, Scope, and Closures\n\nJavaScript offers two main ways to define functions, and both appear frequently in DSA code:\n\n\n```javascript\n// Function declaration (hoisted, usable before its definition)\nfunction dfs(node, visited) {\n if (!node || visited.has(node)) return;\n visited.add(node);\n for (const neighbor of node.neighbors) {\n dfs(neighbor, visited);\n }\n}\n\n// Arrow function (not hoisted, concise for callbacks)\nconst compare = (a, b) => a - b;\n\n// Arrow function with body\nconst isValid = (s) => {\n const stack = [];\n // ... implementation\n return stack.length === 0;\n};\n```\n\n\nFor DSA, use function declarations for your main solution functions and arrow functions for comparators, callbacks, and short helper functions. The choice is mostly style, but there is one practical difference: function declarations are hoisted, so you can call them before they appear in the code. Arrow functions are not.\n\n### Pass-by-Value for Primitives, Pass-by-Reference for Objects\n\nJavaScript passes primitives (numbers, strings, booleans) by value and objects (arrays, maps, sets, plain objects) by reference. This distinction matters for many DSA problems:\n\n\n```javascript\nfunction addToArray(arr, val) {\n arr.push(val); // Modifies the original array\n}\n\nfunction tryToReassign(arr) {\n arr = [99, 100]; // This does NOT affect the original\n}\n\nconst nums = [1, 2, 3];\naddToArray(nums, 4); // nums is now [1, 2, 3, 4]\ntryToReassign(nums); // nums is still [1, 2, 3, 4]\n```\n\n\nThis matters for backtracking. When you add a path to your results, you must copy the array. Otherwise, all results point to the same array that gets modified during backtracking:\n\n\n```javascript\nfunction backtrack(path, results, choices) {\n if (isComplete(path)) {\n results.push([...path]); // MUST spread-copy! Not results.push(path)\n return;\n }\n for (const choice of choices) {\n path.push(choice);\n backtrack(path, results, choices);\n path.pop(); // undo the choice\n }\n}\n```\n\n\nThe `[...path]` spread creates a shallow copy of the array.\n\n### Closures\n\nClosures are useful in JavaScript for memoization patterns:\n\n\n```javascript\n// A function that remembers its enclosing scope\nfunction createMemoizedDFS() {\n const memo = new Map();\n\n return function dfs(state) {\n if (memo.has(state)) return memo.get(state);\n // ... compute result\n memo.set(state, result);\n return result;\n };\n}\n```\n\n\nYou will not need closures for most standard DSA problems, but they come up in design problems (like LRU Cache) and can make memoization code cleaner.\n\nArrow functions and destructuring fit naturally with backtracking and callback patterns. The spread operator `[...path]` is the idiomatic way to copy arrays in JS, and destructuring `const [a, b] = pair` makes working with tuples clean and readable.\n\n---\n\n# Arrays\n\nArrays are the core data structure for DSA in JavaScript. They are dynamic (no fixed size), zero-indexed, and come with many built-in methods. Arrays appear in nearly every problem.\n\n### Creation and Initialization\n\n\n```javascript\n// Literal\nconst nums = [1, 2, 3, 4, 5];\n\n// Fixed size, filled with a value\nconst visited = new Array(n).fill(false);\nconst dp = new Array(n + 1).fill(0);\n\n// Empty array to build up\nconst result = [];\n```\n\n\nThe `.length` property (no parentheses) gives the current size:\n\n\n```javascript\nnums.length // 5\n```\n\n\n### 2D Array Initialization\n\nWatch for this pattern:\n\n\n```javascript\n// WRONG: all rows share the SAME inner array reference!\nconst matrix = new Array(rows).fill(new Array(cols).fill(0));\nmatrix[0][0] = 5; // This changes ALL rows' first element to 5!\n\n// CORRECT: each row is a separate array\nconst matrix = Array.from({ length: rows }, () => new Array(cols).fill(0));\nmatrix[0][0] = 5; // Only affects row 0\n```\n\n\nThe 2D array initialization gotcha is a JavaScript-specific trap. `fill(new Array(...))` evaluates `new Array(...)` once and fills every slot with a reference to that single array. Use `Array.from()` with a mapping function to create independent row arrays.\n\n### Essential Array Methods\n\n\n| Method | Mutates? | Returns | Time | DSA Use |\n|--------|----------|---------|------|---------|\n| `push(val)` | Yes | new length | O(1) | Append to end (stack push) |\n| `pop()` | Yes | removed element | O(1) | Remove from end (stack pop) |\n| `shift()` | Yes | removed element | O(n) | Remove from front (queue dequeue) |\n| `unshift(val)` | Yes | new length | O(n) | Add to front |\n| `splice(i, count, ...items)` | Yes | removed elements | O(n) | Remove/insert at index |\n| `slice(start, end)` | No | new array | O(k) | Copy a portion |\n| `concat(arr2)` | No | new array | O(n+m) | Merge arrays |\n| `reverse()` | Yes | same array | O(n) | Reverse in place |\n| `includes(val)` | No | boolean | O(n) | Linear search |\n| `indexOf(val)` | No | index or -1 | O(n) | Find first occurrence |\n| `fill(val, start, end)` | Yes | same array | O(n) | Fill range with value |\n| `flat(depth)` | No | new array | O(n) | Flatten nested arrays |\n\n\nMethods like `sort()`, `reverse()`, `splice()`, `fill()` modify the array in place. Methods like `slice()`, `concat()`, `map()`, `filter()` return new arrays.\n\n### Stack Operations with Arrays\n\nArrays are your stack in JavaScript. No need for a separate class:\n\n\n```javascript\nconst stack = [];\nstack.push(42); // push: O(1)\nstack.push(17);\nstack.pop(); // pop: O(1), returns 17\nstack[stack.length - 1]; // peek: O(1), returns 42\nstack.length === 0; // isEmpty check\n```\n\n\n### Queue Operations: The O(n) Trap\n\nJavaScript's limitations show up with the queue operations. The naive approach uses `shift()` as dequeue:\n\n\n```javascript\n// NAIVE queue (shift is O(n), avoid for large inputs!)\nconst queue = [];\nqueue.push(42); // enqueue: O(1)\nqueue.shift(); // dequeue: O(n)! Shifts all elements left\n```\n\n\nFor BFS on a graph with 100,000 nodes, using `shift()` makes the algorithm O(n^2) instead of O(n). We will cover a proper queue implementation in the Collections section.\n\nFor problems with small inputs (n < 10,000), `shift()` is acceptable on LeetCode. V8's internal optimizations make the constant factor small. Use your judgment based on the problem constraints.\n\n### The 4-Directional Neighbor Pattern\n\nGrid problems (number of islands, shortest path in maze) need to visit adjacent cells. This pattern appears in almost every grid BFS/DFS:\n\n\n```javascript\nconst directions = [[-1, 0], [1, 0], [0, -1], [0, 1]];\n\nfor (const [dr, dc] of directions) {\n const newRow = row + dr;\n const newCol = col + dc;\n if (newRow >= 0 && newRow < rows && newCol >= 0 && newCol < cols) {\n // process neighbor at (newRow, newCol)\n }\n}\n```\n\n\n### Destructuring Swap\n\nA convenient feature for DSA. No temporary variable needed:\n\n\n```javascript\n[arr[i], arr[j]] = [arr[j], arr[i]]; // Swap elements\n[a, b] = [b, a]; // Swap variables\n```\n\n\n### Spread Operator for Copies\n\n\n```javascript\nconst copy = [...nums]; // Shallow copy\nconst merged = [...arr1, ...arr2]; // Concatenate\n```\n\n\n### Array.from() Utility\n\n`Array.from()` is a versatile tool in JavaScript for DSA:\n\n\n```javascript\n// Create array of specific length filled with value\nArray.from({ length: 26 }, () => 0) // [0, 0, ..., 0] (26 zeros)\n\n// Create array with index-based values\nArray.from({ length: n }, (_, i) => i) // [0, 1, 2, ..., n-1]\n\n// Convert string to character array\nArray.from(\"hello\") // ['h', 'e', 'l', 'l', 'o']\n\n// Create 2D array\nArray.from({ length: rows }, () => new Array(cols).fill(0))\n```\n\n\n---\n\n# Strings\n\nStrings in JavaScript are **immutable**. Every time you modify a string, JavaScript creates a new object. This has an important performance implication:\n\n\n```javascript\n// BAD: O(n^2) because each += creates a new string\nlet result = \"\";\nfor (const c of chars) {\n result += c; // Creates a new string every iteration\n}\n\n// GOOD: O(n) with array join\nconst parts = [];\nfor (const c of chars) {\n parts.push(c);\n}\nconst result = parts.join(\"\");\n```\n\n\nJavaScript has no `StringBuilder` class. The `Array.push()` + `.join(\"\")` pattern is the standard alternative. Array `join` concatenates all elements into a single string with the separator between them.\n\n### No Char Type\n\nJavaScript has no character type. A \"character\" is just a string of length 1:\n\n\n```javascript\nconst s = \"hello\";\ns[0] // \"h\" (a string, not a char)\ntypeof s[0] // \"string\"\ns.charAt(0) // \"h\" (equivalent to s[0])\n```\n\n\nThis means you cannot compare characters with `<` and `>` in the numeric sense directly. Character comparisons work lexicographically as string comparisons, which is what you want for most DSA problems.\n\n### String Methods\n\n\n| Method | Returns | Example | DSA Use |\n|--------|---------|---------|---------|\n| `s[i]` or `s.charAt(i)` | string | `s[0]` | Access character |\n| `s.length` | number | `s.length` | Loop bounds (property, no parens) |\n| `s.slice(start, end)` | string | `s.slice(0, 3)` | Substring (start inclusive, end exclusive) |\n| `s.split(sep)` | array | `s.split(\" \")` | Tokenize |\n| `s.indexOf(str)` | number | `s.indexOf(\"ab\")` | Find substring (-1 if not found) |\n| `s.includes(str)` | boolean | `s.includes(\"ab\")` | Substring check |\n| `s.startsWith(pre)` | boolean | `s.startsWith(\"ab\")` | Prefix check |\n| `s.endsWith(suf)` | boolean | `s.endsWith(\"ab\")` | Suffix check |\n| `s.repeat(n)` | string | `\"ab\".repeat(3)` | Repeat: `\"ababab\"` |\n| `s.trim()` | string | `s.trim()` | Remove surrounding whitespace |\n| `s.toLowerCase()` | string | | Case conversion |\n| `s.toUpperCase()` | string | | Case conversion |\n| `s.replace(a, b)` | string | | Replace first occurrence |\n| `s.replaceAll(a, b)` | string | | Replace all occurrences |\n\n\n### Character Operations\n\nJavaScript has no `Character` utility class. You use `charCodeAt()` and `String.fromCharCode()` instead:\n\n\n```javascript\ns.charCodeAt(0) // Unicode code point of first character\nString.fromCharCode(97) // \"a\"\n\n// Map 'a'-'z' to 0-25\ns.charCodeAt(0) - 97 // 97 is the code for 'a'\n// Or more readably:\ns.charCodeAt(0) - 'a'.charCodeAt(0)\n\n// Map '0'-'9' to 0-9\ns.charCodeAt(0) - 48 // 48 is the code for '0'\n\n// Character type checks (no built-in functions, use regex)\n/[a-zA-Z]/.test(c) // isLetter\n/[0-9]/.test(c) // isDigit\n/[a-zA-Z0-9]/.test(c) // isLetterOrDigit\nc === c.toLowerCase() // isLowerCase (for letters)\nc === c.toUpperCase() // isUpperCase (for letters)\n```\n\n\n### Frequency Array Pattern\n\n\n```javascript\n// Frequency array for lowercase letters (26 slots)\nconst freq = new Array(26).fill(0);\nfor (const c of s) {\n freq[c.charCodeAt(0) - 97]++;\n}\n// freq[0] = count of 'a', freq[1] = count of 'b', etc.\n```\n\n\nThis is faster and more memory-efficient than `Map` when the character set is known and small (lowercase letters, digits, etc.).\n\n### Template Literals for Composite Keys\n\nTemplate literals (backtick strings) are one of JavaScript's most useful features for DSA:\n\n\n```javascript\n// Creating composite keys for Set or Map (very common pattern)\nconst key = `${row},${col}`;\nvisited.add(`${row},${col}`);\n\n// Checking membership\nif (visited.has(`${newRow},${newCol}`)) continue;\n```\n\n\nThe template literal `` `${row},${col}` `` pattern is common in JavaScript for creating composite keys in Sets and Maps. In grid BFS problems, this is the standard way to track visited cells.\n\n---\n\n# Collections: Map, Set, and Object\n\nChoosing the right collection is often the difference between an O(n) and an O(n^2) solution. JavaScript's built-in collections are small in number, but each has its own quirks worth knowing.\n\n\n```mermaid\nflowchart TD\n BUILT[\"Built-in Collections\"]\n ARR[\"Array\"]\n MAP[\"Map\"]\n SET[\"Set\"]\n OBJ[\"Object
(as map)\"]\n MISSING[\"Must Implement\"]\n Q[\"Queue\"]\n PQ[\"PriorityQueue\"]\n TM[\"TreeMap /
TreeSet\"]\n\n BUILT --> ARR\n BUILT --> MAP\n BUILT --> SET\n BUILT --> OBJ\n MISSING --> Q\n MISSING --> PQ\n MISSING --> TM\n\n style BUILT fill:#00ceff,stroke:#000,color:#000\n style ARR fill:#38d9a9,stroke:#000,color:#000\n style MAP fill:#38d9a9,stroke:#000,color:#000\n style SET fill:#38d9a9,stroke:#000,color:#000\n style OBJ fill:#38d9a9,stroke:#000,color:#000\n style MISSING fill:#ffa94d,stroke:#000,color:#000\n style Q fill:#ff8787,stroke:#000,color:#000\n style PQ fill:#ff8787,stroke:#000,color:#000\n style TM fill:#ff8787,stroke:#000,color:#000\n```\n\n\n### Map: The HashMap Equivalent\n\nES6 `Map` is JavaScript's hash map. It offers O(1) average-case `get`, `set`, `has`, and `delete`:\n\n\n```javascript\nconst freq = new Map();\n\n// Frequency counting (most common Map pattern)\nfor (const c of s) {\n freq.set(c, (freq.get(c) ?? 0) + 1);\n}\n\n// Key operations\nfreq.has('a'); // Check if key exists: O(1)\nfreq.get('a'); // Get value (returns undefined if missing): O(1)\nfreq.set('a', 5); // Set value: O(1)\nfreq.delete('a'); // Remove key: O(1)\nfreq.size; // Number of entries (property, not method!)\nfreq.clear(); // Remove all entries\n\n// Iteration (insertion order is preserved)\nfor (const [key, value] of freq) { /* key-value pairs */ }\nfor (const key of freq.keys()) { /* keys only */ }\nfor (const value of freq.values()) { /* values only */ }\n```\n\n\n### Map vs Object\n\nPlain objects (`{}`) can also serve as hash maps, but with limitations:\n\n\n| Feature | `Map` | `Object` |\n|---------|-------|----------|\n| Key types | Any (numbers, objects, arrays) | Strings and Symbols only |\n| Size | `.size` property | `Object.keys(obj).length` |\n| Iteration order | Insertion order guaranteed | Mostly insertion order |\n| Performance | Optimized for frequent adds/deletes | Optimized for static structures |\n| Default keys | None | Has prototype properties |\n| DSA recommendation | **Default choice** | Fine for simple string-key frequency maps |\n\n\n\n```javascript\n// Object as a map (fine for simple string-key cases)\nconst freq = {};\nfor (const c of s) {\n freq[c] = (freq[c] ?? 0) + 1;\n}\n\n// Check existence\nif (c in freq) { /* exists */ }\nif (freq[c] !== undefined) { /* exists */ }\n\n// Iterate\nfor (const key of Object.keys(freq)) { /* keys */ }\nfor (const [key, value] of Object.entries(freq)) { /* key-value pairs */ }\n```\n\n\nUse `Map` as your default. Use objects only when you are counting frequencies of characters or short strings and want the most concise code.\n\n### Set: The HashSet Equivalent\n\n\n```javascript\nconst visited = new Set();\n\nvisited.add(node); // Add element: O(1)\nvisited.has(node); // Check membership: O(1)\nvisited.delete(node); // Remove element: O(1)\nvisited.size; // Number of elements\n\n// Create from array (deduplication!)\nconst unique = new Set(nums);\nconst uniqueArr = [...new Set(nums)]; // Back to array\n\n// Iteration\nfor (const val of visited) { /* values */ }\n```\n\n\nJavaScript's `Set.add()` returns the Set itself, not a boolean indicating whether the element was new. To check if an element was already present, call `has()` before `add()`:\n\n\n```javascript\n// Detect duplicates\nfor (const num of nums) {\n if (visited.has(num)) return true; // Duplicate found\n visited.add(num);\n}\nreturn false;\n```\n\n\n**Important:** Sets use reference equality for objects and arrays. `new Set([[1,2], [1,2]])` has size 2, not 1, because the two `[1,2]` arrays are different objects. For composite keys, serialize to strings: `visited.add(`${row},${col}`)`.\n\n### Queue Implementation\n\nJavaScript has no built-in queue with O(1) dequeue. A lightweight implementation using an object as a sparse array with head/tail pointers:\n\n\n```javascript\nclass Queue {\n constructor() {\n this.items = {};\n this.head = 0;\n this.tail = 0;\n }\n enqueue(val) {\n this.items[this.tail++] = val;\n }\n dequeue() {\n if (this.isEmpty()) return undefined;\n const val = this.items[this.head];\n delete this.items[this.head++];\n return val;\n }\n peek() {\n return this.items[this.head];\n }\n get size() {\n return this.tail - this.head;\n }\n isEmpty() {\n return this.tail === this.head;\n }\n}\n```\n\n\nBFS using this queue:\n\n\n```javascript\nfunction bfs(graph, start) {\n const visited = new Set([start]);\n const queue = new Queue();\n queue.enqueue(start);\n\n while (!queue.isEmpty()) {\n const node = queue.dequeue();\n for (const neighbor of (graph.get(node) ?? [])) {\n if (!visited.has(neighbor)) {\n visited.add(neighbor);\n queue.enqueue(neighbor);\n }\n }\n }\n}\n```\n\n\nFor level-order traversal, capture the queue size at the start of each level:\n\n\n```javascript\nlet level = 0;\nwhile (!queue.isEmpty()) {\n const levelSize = queue.size; // Capture before processing\n for (let i = 0; i < levelSize; i++) {\n const node = queue.dequeue();\n // ... process node, enqueue children\n }\n level++;\n}\n```\n\n\n### PriorityQueue: Must Implement Yourself\n\nJavaScript has no built-in priority queue. For problems like top-K elements, Dijkstra's algorithm, or merge-K-sorted-lists, you need a min-heap. A minimal implementation:\n\n\n```javascript\nclass MinHeap {\n constructor(compareFn = (a, b) => a - b) {\n this.heap = [];\n this.compare = compareFn;\n }\n\n push(val) {\n this.heap.push(val);\n this._siftUp(this.heap.length - 1);\n }\n\n pop() {\n if (this.heap.length === 0) return undefined;\n const top = this.heap[0];\n const last = this.heap.pop();\n if (this.heap.length > 0) {\n this.heap[0] = last;\n this._siftDown(0);\n }\n return top;\n }\n\n peek() {\n return this.heap[0];\n }\n\n get size() {\n return this.heap.length;\n }\n\n isEmpty() {\n return this.heap.length === 0;\n }\n\n _siftUp(i) {\n while (i > 0) {\n const parent = Math.floor((i - 1) / 2);\n if (this.compare(this.heap[i], this.heap[parent]) >= 0) break;\n [this.heap[i], this.heap[parent]] = [this.heap[parent], this.heap[i]];\n i = parent;\n }\n }\n\n _siftDown(i) {\n const n = this.heap.length;\n while (true) {\n let smallest = i;\n const left = 2 * i + 1;\n const right = 2 * i + 2;\n if (left < n && this.compare(this.heap[left], this.heap[smallest]) < 0) smallest = left;\n if (right < n && this.compare(this.heap[right], this.heap[smallest]) < 0) smallest = right;\n if (smallest === i) break;\n [this.heap[i], this.heap[smallest]] = [this.heap[smallest], this.heap[i]];\n i = smallest;\n }\n }\n}\n```\n\n\nUsage:\n\n\n```javascript\n// Min-heap (default)\nconst minHeap = new MinHeap();\nminHeap.push(5);\nminHeap.push(2);\nminHeap.push(8);\nminHeap.pop(); // 2\n\n// Max-heap (reverse comparator)\nconst maxHeap = new MinHeap((a, b) => b - a);\n\n// Custom objects (sort by frequency, then by value)\nconst heap = new MinHeap((a, b) => a[1] !== b[1] ? a[1] - b[1] : a[0] - b[0]);\nheap.push([3, 5]); // [value, frequency]\n```\n\n\nState up front that you are using a simplified heap because JavaScript lacks a built-in PriorityQueue; in real interviews this is usually accepted, and showing that you know the heap interface and can implement it if needed is what matters.\n\n### No TreeMap / TreeSet\n\nJavaScript has no sorted map or sorted set. This is a disadvantage for problems that need:\n\n- Finding the floor/ceiling of a key (nearest smaller/larger)\n- Range queries on keys\n- Maintaining elements in sorted order with O(log n) insertions\n\nWorkarounds:\n\n1. **Sorted array + binary search:** Maintain a sorted array and use binary search for lookups. Insertion is O(n) due to shifting, but works for small datasets.\n2. **Sort when needed:** If you only need sorted access at the end, collect elements and sort once.\n3. **Accept the limitation:** In a JavaScript interview, mention the missing data structure and discuss the trade-off with the interviewer.\n\n### Collections Quick Reference\n\n\n| Collection | Type | Key Methods | Time Complexity | DSA Use |\n|------------|------|-------------|-----------------|---------|\n| `Array` | Dynamic array | `push`, `pop`, `shift`, `splice`, `slice`, `sort` | push/pop O(1), shift O(n), access O(1) | Stacks, results, DP tables |\n| `Map` | Hash map | `set`, `get`, `has`, `delete`, `size` | O(1) average | Frequency counting, two-sum |\n| `Set` | Hash set | `add`, `has`, `delete`, `size` | O(1) average | Visited tracking, dedup |\n| `Object` | String-key map | bracket access, `in`, `Object.keys` | O(1) average | Simple frequency maps |\n| `Queue` (custom) | FIFO queue | `enqueue`, `dequeue`, `peek`, `size` | O(1) all | BFS |\n| `MinHeap` (custom) | Priority queue | `push`, `pop`, `peek`, `size` | O(log n) push/pop | Top-K, Dijkstra |\n\n\n---\n\n# Sorting and Comparators\n\nSorting is fundamental to DSA. And JavaScript's default sort behavior is a frequent source of bugs.\n\n### The Default Sort Trap\n\n\n```javascript\n[10, 9, 80, 1].sort();\n// Result: [1, 10, 80, 9] (WRONG! Sorted as strings, not numbers!)\n```\n\n\n`Array.sort()` converts elements to strings and sorts lexicographically by default. The string `\"10\"` comes before `\"9\"` because `\"1\"` < `\"9\"` in Unicode code points. **Always pass a comparator for numeric sorting:**\n\n\n```javascript\n[10, 9, 80, 1].sort((a, b) => a - b);\n// Result: [1, 9, 10, 80] (correct!)\n```\n\n\n### Comparator Pattern\n\nThe comparator function takes two elements and returns:\n\n- Negative: `a` comes first\n- Zero: order does not matter\n- Positive: `b` comes first\n\n\n```javascript\n// Sort intervals by start time\nintervals.sort((a, b) => a[0] - b[0]);\n\n// Sort by length, then alphabetically\nwords.sort((a, b) => {\n if (a.length !== b.length) return a.length - b.length;\n return a.localeCompare(b);\n});\n\n// Descending order\nnums.sort((a, b) => b - a);\n\n// Sort objects by a property\npeople.sort((a, b) => a.age - b.age);\n```\n\n\n### Sort Mutates the Original Array\n\nUnlike methods like `map` and `filter` which return new arrays, `sort()` modifies the array in place and returns the same array reference. If you need to preserve the original:\n\n\n```javascript\nconst sorted = [...nums].sort((a, b) => a - b); // Copy, then sort\n```\n\n\n### Stability\n\n`Array.sort()` is guaranteed stable in all modern JavaScript engines since ES2019. This means elements with equal sort keys maintain their original relative order. The underlying algorithm varies by engine: V8 (Chrome, Node.js) uses TimSort, while JavaScriptCore (Safari) and SpiderMonkey (Firefox) use other stable sorts.\n\n### Overflow Warning\n\nThe `(a, b) => a - b` comparator can theoretically overflow if `a` and `b` are very large numbers of opposite sign. This is rare in DSA because JavaScript numbers are doubles with a wide range. But if you need to be safe:\n\n\n```javascript\nconst safeCompare = (a, b) => (a < b ? -1 : a > b ? 1 : 0);\n```\n\n\n---\n\n# Functional Patterns for DSA\n\nJavaScript's functional array methods can make DSA code more concise. Use them when they improve readability, but do not force them when a simple loop is clearer.\n\n### map, filter, reduce\n\n\n```javascript\n// Sum of array\nconst sum = nums.reduce((acc, val) => acc + val, 0);\n\n// Filter even numbers\nconst evens = nums.filter(n => n % 2 === 0);\n\n// Transform values\nconst doubled = nums.map(n => n * 2);\n\n// Check if any/all meet condition\nnums.some(n => n > 10); // true if any element > 10\nnums.every(n => n > 0); // true if all elements > 0\n\n// Find first matching element\nnums.find(n => n > 10); // first element > 10, or undefined\nnums.findIndex(n => n > 10); // index of first match, or -1\n```\n\n\n### Frequency Counting Patterns\n\n\n```javascript\n// With Map (recommended)\nconst freq = new Map();\nfor (const c of s) {\n freq.set(c, (freq.get(c) ?? 0) + 1);\n}\n\n// With Object (concise for string keys)\nconst freq = {};\nfor (const c of s) {\n freq[c] = (freq[c] ?? 0) + 1;\n}\n\n// With reduce (most compact, but less readable)\nconst freq = [...s].reduce((m, c) => {\n m[c] = (m[c] ?? 0) + 1;\n return m;\n}, {});\n```\n\n\n### Adjacency List Building\n\n\n```javascript\n// With Map\nconst graph = new Map();\nfor (const [u, v] of edges) {\n if (!graph.has(u)) graph.set(u, []);\n if (!graph.has(v)) graph.set(v, []);\n graph.get(u).push(v);\n graph.get(v).push(u); // Omit for directed graph\n}\n```\n\n\n### Destructuring in Iterations\n\n\n```javascript\n// Map entries\nfor (const [key, value] of map) { /* ... */ }\n\n// Array with index\nfor (const [i, val] of nums.entries()) { /* ... */ }\n\n// Nested array unpacking\nfor (const [u, v, weight] of edges) { /* ... */ }\n```\n\n\n### Array.from() for Generation\n\n\n```javascript\n// Range [0, 1, 2, ..., n-1]\nArray.from({ length: n }, (_, i) => i);\n\n// Range [1, 2, 3, ..., n]\nArray.from({ length: n }, (_, i) => i + 1);\n\n// Initialize 2D grid\nArray.from({ length: rows }, () => new Array(cols).fill(0));\n```\n\n\n---\n\n# Null and Undefined Handling\n\nJavaScript has two \"nothing\" values, and understanding the difference matters for DSA.\n\n- `null`**:** Intentional absence of a value. Used as tree/linked list terminators. You set this explicitly.\n- `undefined`**:** Variable declared but not assigned, missing object/map property, or function with no return value. The engine sets this.\n\nIn DSA, `null` appears when a tree node has no left or right child, or when a linked list ends. `undefined` appears when you call `map.get(key)` for a missing key or access an array index out of bounds.\n\n### Three Rules for Null Safety\n\n**Rule 1: Guard clauses for edge cases.**\n\n\n```javascript\nif (!root) return null; // Tree is empty\nif (!head) return null; // Linked list is empty\nif (!nums || nums.length === 0) return []; // Array is empty or null\n```\n\n\nNote: `!null` and `!undefined` are both `true`, so `if (!root)` catches both.\n\n**Rule 2: Use **`??`** for defaults, not **`||`**.**\n\n\n```javascript\nconst count = map.get(key) ?? 0; // Only replaces null/undefined\nconst count = map.get(key) || 0; // ALSO replaces 0, \"\", false (dangerous!)\n```\n\n\nIf the map stores `0` as a legitimate value, `|| 0` would incorrectly treat it as missing. The `??` operator only triggers for `null` and `undefined`.\n\n**Rule 3: Optional chaining for safe navigation.**\n\n\n```javascript\nconst val = node?.left?.val; // undefined if any link is null/undefined\nconst len = arr?.[0]?.length; // Safe bracket access\nconst result = obj?.method?.(); // Safe method call\n```\n\n\n---\n\n# Iterating and Modifying Collections Safely\n\nJavaScript does not throw any error when you modify a collection during iteration. But modifying arrays during iteration still causes subtle bugs.\n\n### Arrays: Use Backward Loop for Safe Removal\n\n\n```javascript\n// BUGGY: forward loop with splice skips elements\nfor (let i = 0; i < arr.length; i++) {\n if (shouldRemove(arr[i])) {\n arr.splice(i, 1);\n // After splice, the next element shifts to index i,\n // but the loop increments i, so it gets skipped\n }\n}\n\n// CORRECT: backward loop\nfor (let i = arr.length - 1; i >= 0; i--) {\n if (shouldRemove(arr[i])) {\n arr.splice(i, 1); // Removal does not affect earlier indices\n }\n}\n\n// ALSO CORRECT: build a new array\nconst filtered = arr.filter(item => !shouldRemove(item));\n```\n\n\n### Map and Set: Safe Deletion During Iteration\n\nJavaScript's `Map` and `Set` allow you to delete the current element during `for...of` iteration. This is part of the ES6 specification:\n\n\n```javascript\nfor (const [key, value] of map) {\n if (shouldRemove(value)) {\n map.delete(key); // Safe in JavaScript!\n }\n}\n\nfor (const val of set) {\n if (shouldRemove(val)) {\n set.delete(val); // Also safe!\n }\n}\n```\n\n\n### Best Practice\n\nIn DSA, you rarely need to modify collections during iteration. Most problems build new collections from existing ones. When you do need to remove elements, prefer building a new array with `filter()` or using the backward loop pattern.\n\n---\n\n# Recursion and the Call Stack\n\nRecursion is fundamental to DSA: tree traversals, DFS, backtracking, and divide-and-conquer all rely on it. JavaScript handles recursion the same as other languages, with one important limitation.\n\n### Stack Depth Limit\n\nV8 (the engine behind Chrome and Node.js) has a call stack limit of roughly **10,000 to 15,000 frames**, depending on the size of each frame. The limit cannot be changed from inside the running program, though Node can be launched with `--stack-size=N` (in KB) to raise it. Browsers offer no such flag, so for web code the limit is effectively fixed.\n\n\n| Scenario | Typical Depth | Risk |\n|----------|--------------|------|\n| Balanced binary tree | O(log n) | Safe for n up to 10^6 |\n| Linked list / skewed tree | O(n) | Dangerous if n > 10,000 |\n| Backtracking | O(d) | Usually safe (d is decision depth) |\n| DFS on graph | O(n) | Dangerous for large n |\n\n\n### Converting Recursive DFS to Iterative\n\nWhen the input is large and recursion depth could exceed 10,000, convert to an iterative approach with an explicit stack:\n\n\n```javascript\n// Recursive DFS (risks stack overflow for large graphs)\nfunction dfsRecursive(node, graph, visited) {\n visited.add(node);\n for (const neighbor of (graph.get(node) ?? [])) {\n if (!visited.has(neighbor)) {\n dfsRecursive(neighbor, graph, visited);\n }\n }\n}\n\n// Iterative DFS (safe for any size)\nfunction dfsIterative(start, graph, visited) {\n const stack = [start];\n while (stack.length > 0) {\n const node = stack.pop();\n if (visited.has(node)) continue;\n visited.add(node);\n for (const neighbor of (graph.get(node) ?? [])) {\n if (!visited.has(neighbor)) {\n stack.push(neighbor);\n }\n }\n }\n}\n```\n\n\n### No Tail Call Optimization in Practice\n\nJavaScript's ES2015 specification defines proper tail calls, but only Safari (JavaScriptCore) implements them. Chrome and Node.js do not. This means even \"tail-recursive\" functions will still add a frame per call. Always assume recursion adds to the stack.\n\n---\n\n# Graph Representation Patterns\n\nGraphs appear in a huge number of DSA problems: shortest path, connected components, topological sort, and more. The two main representations map directly to when each is appropriate.\n\n### Approach 1: Array of Arrays (Contiguous Node IDs 0 to n-1)\n\nWhen nodes are numbered 0 through n-1, use an array:\n\n\n```javascript\nconst graph = Array.from({ length: n }, () => []);\n\nfor (const [u, v] of edges) {\n graph[u].push(v);\n graph[v].push(u); // Omit for directed graph\n}\n\n// Access neighbors\nfor (const neighbor of graph[node]) {\n // process neighbor\n}\n```\n\n\n### Approach 2: Map (Sparse or Non-Contiguous Node IDs)\n\nWhen node IDs are not contiguous (like string labels or large integers):\n\n\n```javascript\nconst graph = new Map();\n\nfor (const [u, v] of edges) {\n if (!graph.has(u)) graph.set(u, []);\n if (!graph.has(v)) graph.set(v, []);\n graph.get(u).push(v);\n graph.get(v).push(u);\n}\n\n// Access neighbors (with fallback for isolated nodes)\nfor (const neighbor of (graph.get(node) ?? [])) {\n // process neighbor\n}\n```\n\n\n### Weighted Graphs\n\nStore edge weights alongside destination nodes using small arrays:\n\n\n```javascript\n// [destination, weight]\ngraph[from].push([to, weight]);\n\n// Usage in Dijkstra-style traversal\nfor (const [neighbor, weight] of graph[node]) {\n const newDist = dist[node] + weight;\n // ...\n}\n```\n\n\n### Comparison\n\n\n| Feature | Array of Arrays | Map |\n|---------|----------------|-----|\n| Node IDs | Must be 0 to n-1 | Any type (int, string) |\n| Memory | Compact, no hash overhead | Hash table overhead |\n| Access speed | O(1) direct index | O(1) average (hash lookup) |\n| Use when | Nodes are numbered, dense | Nodes are sparse, string labels |\n| Most problems | **This one** | Graph with city names, etc. |\n\n\n---\n\n# Pair and Tuple Alternatives\n\nJavaScript has no Pair or Tuple type, but the language provides clean alternatives through arrays and destructuring.\n\n### Option 1: Arrays (Most Common)\n\n\n```javascript\n// Store pairs/tuples as small arrays\nqueue.push([row, col]);\nqueue.push([row, col, distance]);\nheap.push([cost, node]);\n\n// Destructure when extracting\nconst [r, c] = queue.shift();\nconst [cost, node] = heap.pop();\n```\n\n\n### Option 2: Objects (When Clarity Matters)\n\n\n```javascript\n// Shorthand property names\nqueue.push({ row, col, dist });\n\n// Destructure\nconst { row, col, dist } = queue.shift();\n```\n\n\n### Option 3: String Keys for Composite Map/Set Keys\n\nSince arrays use reference equality (`[1,2] !== [1,2]`), you cannot use arrays directly as Map keys or Set values for deduplication. Serialize to strings:\n\n\n```javascript\n// Track visited coordinates\nconst visited = new Set();\nvisited.add(`${row},${col}`);\nif (visited.has(`${newRow},${newCol}`)) continue;\n\n// Track visited states (row, col, direction)\nvisited.add(`${row},${col},${dir}`);\n```\n\n\nDestructuring makes arrays a good fit for tuples in JavaScript. `const [a, b] = pair` reads naturally and avoids verbose property access.\n\n---\n\n# Deduplication Patterns\n\nTwo main approaches for avoiding duplicates in results.\n\n### Approach 1: Sort and Skip (Preferred for Sorted Input)\n\n\n```javascript\nnums.sort((a, b) => a - b);\n\nfor (let i = 0; i < nums.length; i++) {\n if (i > 0 && nums[i] === nums[i - 1]) continue; // Skip duplicates\n // process nums[i]\n}\n```\n\n\nThis pattern appears in problems like 3Sum, Combination Sum II, and Subsets II. The sort brings duplicates adjacent, and the skip condition ensures each unique value is processed only once at each position.\n\n### Approach 2: Set with Serialization\n\nSince JavaScript Sets compare objects and arrays by reference, you must serialize to strings for deduplication:\n\n\n```javascript\nconst resultSet = new Set();\n\n// Add results as serialized strings\nresultSet.add(JSON.stringify([a, b, c]));\n\n// Convert back to arrays\nconst results = [...resultSet].map(s => JSON.parse(s));\n```\n\n\nThis is useful when you cannot sort the input or when duplicate detection is not straightforward. But `JSON.stringify` and `JSON.parse` are slower than the sort-and-skip approach, so prefer Approach 1 when possible.\n\n---\n\n# Common DSA Idioms in JavaScript\n\n### Element Swapping\n\n\n```javascript\n// Destructuring swap (no temp variable)\n[arr[i], arr[j]] = [arr[j], arr[i]];\n\n// Variable swap\n[a, b] = [b, a];\n```\n\n\n### Sentinel Values\n\n\n```javascript\nlet minVal = Infinity; // Will be replaced by any real value\nlet maxVal = -Infinity; // Will be replaced by any real value\n// Note: Infinity is a global constant, not Math.Infinity\n```\n\n\n### Math Utilities\n\n\n```javascript\nMath.max(a, b) // Maximum of two values\nMath.min(a, b) // Minimum of two values\nMath.abs(a) // Absolute value\nMath.floor(a / b) // Floor division (toward negative infinity)\nMath.ceil(a / b) // Ceiling division (toward positive infinity)\nMath.trunc(a / b) // Truncation toward zero\nMath.sqrt(n) // Square root\nMath.log2(n) // Log base 2\nMath.pow(a, b) // a^b (or use a ** b)\n```\n\n\n**Warning about **`Math.max()`** and **`Math.min()`** with arrays:**\n\n\n```javascript\n// This works for small arrays\nMath.max(...nums); // Spread array as arguments\n\n// This THROWS RangeError for arrays with ~65,000+ elements!\n// Exceeds maximum call stack size because spread creates that many arguments\nMath.max(...largeArray); // RangeError!\n\n// Safe alternative for large arrays\nlet max = -Infinity;\nfor (const num of nums) {\n if (num > max) max = num;\n}\n// Or: nums.reduce((max, n) => Math.max(max, n), -Infinity);\n```\n\n\n### Integer Ceiling Division Without Floating Point\n\n\n```javascript\n// Using Math.ceil (works for positive numbers)\nconst ceil = Math.ceil(a / b);\n\n// Without floating point (avoids precision issues)\nconst ceil = Math.floor((a + b - 1) / b);\n```\n\n\n### Type Conversions\n\n\n```javascript\n// String to number\nNumber(\"42\") // 42\nparseInt(\"42\") // 42\nparseInt(\"42abc\") // 42 (stops at first non-digit, be aware!)\n+\"42\" // 42 (unary plus, concise but less readable)\n\n// Number to string\nString(42) // \"42\"\n(42).toString() // \"42\"\n(42).toString(2) // \"101010\" (binary representation)\n(42).toString(16) // \"2a\" (hexadecimal)\n\n// String to character array\n[...\"hello\"] // ['h', 'e', 'l', 'l', 'o']\n\"hello\".split(\"\") // ['h', 'e', 'l', 'l', 'o']\n\n// Character array to string\n['h', 'e', 'l', 'l', 'o'].join(\"\") // \"hello\"\n```\n\n\n\n```mermaid\nflowchart LR\n STR[\"String\"]\n NUM[\"Number\"]\n ARR[\"Array\"]\n CHAR[\"Char Array\"]\n\n STR -- \"Number(s), parseInt(s), +s\" --> NUM\n NUM -- \"String(n), n.toString()\" --> STR\n STR -- \"[...s], s.split('')\" --> CHAR\n CHAR -- \"arr.join('')\" --> STR\n ARR -- \"JSON.stringify(a)\" --> STR\n STR -- \"JSON.parse(s)\" --> ARR\n NUM -- \"n.toString(2)\" --> STR\n\n style STR fill:#00ceff,stroke:#000,color:#000\n style NUM fill:#ffa94d,stroke:#000,color:#000\n style ARR fill:#38d9a9,stroke:#000,color:#000\n style CHAR fill:#69db7c,stroke:#000,color:#000\n```\n\n\n### Deep Copy Patterns\n\n\n```javascript\n// Shallow copy of 1D array\nconst copy = [...arr];\nconst copy2 = arr.slice();\n\n// Deep copy of 2D array\nconst deep = arr.map(row => [...row]);\n\n// Deep copy of arbitrary objects (slow but universal)\nconst deep = JSON.parse(JSON.stringify(obj));\n\n// Modern deep copy (Node 17+, Chrome 98+, available on LeetCode)\nconst deep = structuredClone(obj);\n```\n\n\nRemember: `[...arr]` and `slice()` are shallow copies. For 2D arrays, you must map over rows and spread each one individually, or the inner arrays will still be shared references.\n\n---\n\n# OOP Basics for Design Problems\n\nJavaScript uses `class` syntax (ES6) for object-oriented code. In DSA, you need classes primarily for node definitions that LeetCode provides, and occasionally for design problems like LRU Cache.\n\n### Standard Node Classes\n\n\n```javascript\n// Linked list node\nclass ListNode {\n constructor(val = 0, next = null) {\n this.val = val;\n this.next = next;\n }\n}\n\n// Binary tree node\nclass TreeNode {\n constructor(val = 0, left = null, right = null) {\n this.val = val;\n this.left = left;\n this.right = right;\n }\n}\n\n// Graph node with neighbors\nclass GraphNode {\n constructor(val = 0, neighbors = []) {\n this.val = val;\n this.neighbors = neighbors;\n }\n}\n\n// Trie node\nclass TrieNode {\n constructor() {\n this.children = {}; // Object map: character -> TrieNode\n this.isEndOfWord = false;\n }\n}\n```\n\n\nJavaScript constructors use default parameters (`val = 0, next = null`) so a single constructor handles all cases.\n\nLeetCode provides `ListNode` and `TreeNode` definitions for you. You do not need to write them yourself, but understanding the structure is essential.\n\n### Building Data Structures Concisely\n\n\n```javascript\n// Build linked list: 1 -> 2 -> 3 -> null\nconst head = new ListNode(1, new ListNode(2, new ListNode(3)));\n\n// Build binary tree: 1\n// / \\\n// 2 3\nconst root = new TreeNode(1, new TreeNode(2), new TreeNode(3));\n```\n\n\n### No Access Modifiers\n\nJavaScript has no `private` or `public` keywords. Class fields declared with `#` prefix are truly private (ES2022), but this is never used in DSA. All properties are public and accessed directly:\n\n\n```javascript\nnode.val // direct access\nnode.next // direct access\nnode.left // direct access\n```\n\n\nThis keeps DSA code concise and easy to read.","pageType":"dsa"}

Get Premium