🚀 JavaScript DSA Patterns - Your Coding Interview Cheat Sheet

Stop memorizing algorithms! Learn the 7 most important patterns that solve 90% of coding interview problems. Simple explanations, clean code, real examples.

🎯 Two Pointers - The Swiss Army Knife

When to use: Sorted arrays, finding pairs, palindromes

The Magic Formula:

JAVASCRIPT
1// Pattern: Start from both ends, move towards center
2let left = 0;
3let right = array.length - 1;
4
5while (left < right) {
6    // Do something with array[left] and array[right]
7    if (condition) {
8        left++;
9    } else {
10        right--;
11    }
12}

Real Example: Two Sum (Sorted Array)

JAVASCRIPT
1function twoSum(nums, target) {
2    let left = 0;
3    let right = nums.length - 1;
4    
5    while (left < right) {
6        const sum = nums[left] + nums[right];
7        
8        if (sum === target) return [left, right];
9        if (sum < target) left++;
10        else right--;
11    }
12    return [];
13}
14
15// Try it: twoSum([2, 7, 11, 15], 9) → [0, 1]

Quick Win: Check Palindrome

JAVASCRIPT
1function isPalindrome(s) {
2    s = s.toLowerCase().replace(/[^a-z0-9]/g, '');
3    let left = 0, right = s.length - 1;
4    
5    while (left < right) {
6        if (s[left] !== s[right]) return false;
7        left++;
8        right--;
9    }
10    return true;
11}
12
13// Try it: isPalindrome("A man, a plan, a canal: Panama") → true

---

🪟 Sliding Window - The Efficiency Master

When to use: Subarrays, substrings, "find max/min in window"

The Magic Formula:

JAVASCRIPT
1let left = 0;
2for (let right = 0; right < array.length; right++) {
3    // Expand window by including array[right]
4    
5    while (/* window is invalid */) {
6        // Shrink window by removing array[left]
7        left++;
8    }
9    
10    // Update result with current window
11}

Real Example: Longest Substring Without Repeating Characters

JAVASCRIPT
1function longestUniqueSubstring(s) {
2    const seen = new Set();
3    let left = 0;
4    let maxLength = 0;
5    
6    for (let right = 0; right < s.length; right++) {
7        // Shrink window until no duplicates
8        while (seen.has(s[right])) {
9            seen.delete(s[left]);
10            left++;
11        }
12        
13        seen.add(s[right]);
14        maxLength = Math.max(maxLength, right - left + 1);
15    }
16    
17    return maxLength;
18}
19
20// Try it: longestUniqueSubstring("abcabcbb") → 3 ("abc")

Quick Win: Max Sum of K Elements

JAVASCRIPT
1function maxSumSubarray(nums, k) {
2    let windowSum = nums.slice(0, k).reduce((a, b) => a + b);
3    let maxSum = windowSum;
4    
5    for (let i = k; i < nums.length; i++) {
6        windowSum = windowSum - nums[i - k] + nums[i];
7        maxSum = Math.max(maxSum, windowSum);
8    }
9    
10    return maxSum;
11}
12
13// Try it: maxSumSubarray([1, 4, 2, 10, 23, 3], 3) → 39

---

🐢🐰 Fast & Slow Pointers - The Cycle Detective

When to use: Linked lists, cycle detection, finding middle element

The Magic Formula:

JAVASCRIPT
1let slow = head;
2let fast = head;
3
4while (fast && fast.next) {
5    slow = slow.next;        // Move 1 step
6    fast = fast.next.next;   // Move 2 steps
7    
8    if (slow === fast) {     // They meet = cycle found!
9        return true;
10    }
11}

Real Example: Detect Cycle in Linked List

JAVASCRIPT
1function hasCycle(head) {
2    let slow = head;
3    let fast = head;
4    
5    while (fast && fast.next) {
6        slow = slow.next;
7        fast = fast.next.next;
8        
9        if (slow === fast) return true;
10    }
11    
12    return false;
13}

Quick Win: Find Middle of Linked List

JAVASCRIPT
1function findMiddle(head) {
2    let slow = head;
3    let fast = head;
4    
5    while (fast && fast.next) {
6        slow = slow.next;
7        fast = fast.next.next;
8    }
9    
10    return slow; // This is the middle!
11}

---

📊 Merge Intervals - The Scheduler

When to use: Meeting rooms, calendars, overlapping ranges

The Magic Formula:

JAVASCRIPT
1// 1. Sort intervals by start time
2intervals.sort((a, b) => a[0] - b[0]);
3
4// 2. Merge overlapping intervals
5const merged = [intervals[0]];
6
7for (let i = 1; i < intervals.length; i++) {
8    const current = intervals[i];
9    const last = merged[merged.length - 1];
10    
11    if (current[0] <= last[1]) {
12        // Overlap! Merge them
13        last[1] = Math.max(last[1], current[1]);
14    } else {
15        // No overlap, add new interval
16        merged.push(current);
17    }
18}

Real Example: Merge Meeting Times

JAVASCRIPT
1function mergeIntervals(intervals) {
2    if (intervals.length <= 1) return intervals;
3    
4    intervals.sort((a, b) => a[0] - b[0]);
5    const merged = [intervals[0]];
6    
7    for (let i = 1; i < intervals.length; i++) {
8        const current = intervals[i];
9        const last = merged[merged.length - 1];
10        
11        if (current[0] <= last[1]) {
12            last[1] = Math.max(last[1], current[1]);
13        } else {
14            merged.push(current);
15        }
16    }
17    
18    return merged;
19}
20
21// Try it: mergeIntervals([[1,3],[2,6],[8,10]]) → [[1,6],[8,10]]

---

🌳 Tree Traversal - The Explorer

When to use: Any tree problem, path finding, level-order processing

The Magic Formulas:

DFS (Depth-First Search)

JAVASCRIPT
1function dfs(node) {
2    if (!node) return;
3    
4    // Process current node
5    console.log(node.val);
6    
7    // Visit children
8    dfs(node.left);
9    dfs(node.right);
10}

BFS (Breadth-First Search)

JAVASCRIPT
1function bfs(root) {
2    const queue = [root];
3    
4    while (queue.length > 0) {
5        const node = queue.shift();
6        console.log(node.val);
7        
8        if (node.left) queue.push(node.left);
9        if (node.right) queue.push(node.right);
10    }
11}

Real Example: Maximum Depth of Binary Tree

JAVASCRIPT
1function maxDepth(root) {
2    if (!root) return 0;
3    
4    const leftDepth = maxDepth(root.left);
5    const rightDepth = maxDepth(root.right);
6    
7    return Math.max(leftDepth, rightDepth) + 1;
8}

---

🔄 Backtracking - The Time Traveler

When to use: Generate all combinations, permutations, solve puzzles

The Magic Formula:

JAVASCRIPT
1function backtrack(currentSolution) {
2    if (/* solution is complete */) {
3        result.push([...currentSolution]);
4        return;
5    }
6    
7    for (let choice of possibleChoices) {
8        // Make choice
9        currentSolution.push(choice);
10        
11        // Explore
12        backtrack(currentSolution);
13        
14        // Undo choice (backtrack!)
15        currentSolution.pop();
16    }
17}

Real Example: Generate All Permutations

JAVASCRIPT
1function permute(nums) {
2    const result = [];
3    
4    function backtrack(current) {
5        if (current.length === nums.length) {
6            result.push([...current]);
7            return;
8        }
9        
10        for (let num of nums) {
11            if (current.includes(num)) continue;
12            
13            current.push(num);       // Make choice
14            backtrack(current);      // Explore
15            current.pop();           // Undo choice
16        }
17    }
18    
19    backtrack([]);
20    return result;
21}
22
23// Try it: permute([1,2,3]) → [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

---

💎 Dynamic Programming - The Memory Master

When to use: Optimization problems, "find maximum/minimum", counting problems

The Magic Formula:

JAVASCRIPT
1// Step 1: Define what dp[i] represents
2// Step 2: Find the recurrence relation
3// Step 3: Handle base cases
4// Step 4: Fill the dp table
5
6const dp = new Array(n + 1).fill(0);
7dp[0] = baseCase;
8
9for (let i = 1; i <= n; i++) {
10    dp[i] = /* some function of previous dp values */;
11}
12
13return dp[n];

Real Example: Fibonacci (The Classic)

JAVASCRIPT
1function fibonacci(n) {
2    if (n <= 1) return n;
3    
4    const dp = [0, 1];
5    
6    for (let i = 2; i <= n; i++) {
7        dp[i] = dp[i - 1] + dp[i - 2];
8    }
9    
10    return dp[n];
11}
12
13// Even better - O(1) space:
14function fibonacciOptimal(n) {
15    if (n <= 1) return n;
16    
17    let prev = 0, curr = 1;
18    
19    for (let i = 2; i <= n; i++) {
20        [prev, curr] = [curr, prev + curr];
21    }
22    
23    return curr;
24}

Real Example: Climbing Stairs

JAVASCRIPT
1function climbStairs(n) {
2    if (n <= 2) return n;
3    
4    let oneStep = 1, twoSteps = 2;
5    
6    for (let i = 3; i <= n; i++) {
7        [oneStep, twoSteps] = [twoSteps, oneStep + twoSteps];
8    }
9    
10    return twoSteps;
11}
12
13// Try it: climbStairs(5) → 8 ways

---

🎯 Quick Practice Problems

Test your pattern recognition skills:

Beginner Level

1. Two Sum (Two Pointers) → [3, 2, 4], target = 6
2. Max Subarray Size K (Sliding Window) → [1, 2, 3, 4, 5], k = 3
3. Reverse Linked List (Iterative) → 1→2→3→4→5

Intermediate Level

4. Meeting Rooms (Merge Intervals) → [[0,30],[5,10],[15,20]]
5. Binary Tree Level Order (BFS) → Print each level
6. Generate Parentheses (Backtracking) → n = 3

Advanced Level

7. Longest Palindromic Substring (DP) → "babad"
8. Course Schedule (Graph + DFS) → Prerequisites array
9. Trapping Rain Water (Two Pointers) → [0,1,0,2,1,0,1,3,2,1,2,1]

---

🚀 Next Steps

1. Pick one pattern and solve 3 problems with it
2. Master the template before moving to the next pattern
3. Practice daily - even 30 minutes helps!
4. Explain your solution out loud (rubber duck debugging)

Recommended Learning Order:

1. Two Pointers → Easy to understand
2. Sliding Window → Builds on Two Pointers
3. Fast & Slow → Fun and intuitive
4. Tree Traversal → Foundation for many problems
5. Backtracking → Logical problem solving
6. Merge Intervals → Real-world applications
7. Dynamic Programming → The final boss!

---

💡 Pro Tips

✅ Do This:

• Focus on understanding the pattern, not memorizing code
• Draw diagrams for complex problems
• Start with brute force, then optimize
• Practice explaining your solution

❌ Avoid This:

• Jumping between patterns too quickly
• Memorizing solutions without understanding
• Skipping the "why" behind each step
• Giving up after one failed attempt

---

Happy coding! 🎉 Remember: Every expert was once a beginner. You've got this!

Like this guide if it helped you crack your next coding interview! ⭐