Skip to main content
Mapagam

36 SECTIONS · 696 TOPICS

Algorithm Patterns Roadmap

  1. Sliding Window Pattern

    1. 1. Fixed-size Window Techniques
    2. Example: Maximum sum of k consecutive elements
    3. 2. Variable-size Window Optimization
    4. Example: Smallest subarray with sum ≥ target
    5. 3. Maximum/Minimum Subarray Problems
    6. Example: Sliding Window Maximum
    7. Example: Maximum Product Subarray
    8. 4. Longest Substring Without Repeating Characters
    9. Example: Longest substring without repeating characters
    10. Example: Longest substring with k distinct characters
    11. 5. Two-pointer Sliding Window Hybrid Approach
    12. Example: Container with most water (opposite direction)
    13. 6. Time Complexity O(n) Analysis
    14. Sliding Window Pattern Summary

  2. Two Pointers Pattern

    1. 1. Opposite Ends Technique (left and right pointers)
    2. Example: Two sum in sorted array
    3. Example: Valid palindrome
    4. 2. Fast and Slow Pointers (Floyd's Cycle Detection)
    5. Example: Detect cycle in linked list
    6. Example: Find middle of linked list
    7. Example: Find cycle start position
    8. 3. In-place Array Manipulation O(1) Space
    9. Example: Remove duplicates from sorted array
    10. Example: Move zeros to end
    11. Example: Sorted squares with negative numbers
    12. 4. Partitioning and Sorting Techniques
    13. Example: Dutch National Flag (Sort colors)
    14. Example: Partition array around pivot
    15. 5. Collision Detection Patterns
    16. Example: Remove nth node from end of list
    17. 6. Space Optimization O(1) Complexity
    18. Example: Reverse string in-place
    19. Two Pointers Pattern Summary

  3. Prefix Sum and Cumulative Arrays

    1. 1. Basic Prefix Sum Implementation
    2. Example: Range sum query using prefix sum
    3. Example: Subarray sum equals k (prefix sum with HashMap)
    4. 2. 2D Prefix Sum for Matrix Range Queries
    5. Example: 2D range sum query (immutable matrix)
    6. 3. Difference Array for Range Updates
    7. Example: Range addition using difference array
    8. Example: Corporate flight bookings
    9. 4. Range Query Optimization Techniques
    10. Immutable Range Queries
    11. Mutable Range Queries
    12. Example: Product of array except self (prefix/suffix product)
    13. 5. Prefix XOR and Bitwise Operations
    14. Example: XOR queries of a subarray
    15. Example: Count triplets with XOR equal to zero
    16. 6. Memory-efficient Prefix Sum Calculations
    17. Example: Running sum with O(1) space
    18. Example: Max sum with rolling variables
    19. Prefix Sum Pattern Summary

  4. Binary Search Pattern

    1. 1. Classic Binary Search Template O(log n)
    2. Example: Classic binary search (find exact target)
    3. Example: Recursive binary search
    4. 2. Lower Bound and Upper Bound Implementation
    5. Example: Lower bound (first >= target)
    6. Example: Upper bound (first > target)
    7. Example: Find first and last position of element
    8. 3. Search in Rotated Sorted Array
    9. Example: Search in rotated sorted array
    10. Example: Find minimum in rotated sorted array
    11. 4. Binary Search on Answer Space Pattern
    12. Example: Koko eating bananas (minimize eating speed)
    13. Example: Capacity to ship packages within D days
    14. 5. Floating Point Binary Search Precision
    15. Example: Square root with precision
    16. Example: Find peak element with fixed iterations
    17. 6. Binary Search Edge Cases and Debugging
    18. Example: Debugging template with invariant comments
    19. Binary Search Pattern Summary

  5. Fast and Slow Pointers (Floyd's Cycle Detection)

    1. 1. Cycle Detection in Linked Lists
    2. Example: Floyd's cycle detection algorithm
    3. Example: Alternative with HashSet (for comparison)
    4. 2. Find Middle of Linked List
    5. Example: Find middle node
    6. Example: Delete middle node
    7. 3. Palindrome Linked List Verification
    8. Example: Check if linked list is palindrome
    9. 4. Intersection of Two Linked Lists
    10. Example: Find intersection node (elegant two-pointer)
    11. Example: Intersection with length calculation
    12. 5. Duplicate Detection in Arrays O(1) Space
    13. Example: Find duplicate number using Floyd's algorithm
    14. 6. Find Starting Point of Cycle
    15. Example: Find cycle start position
    16. Example: Find cycle length
    17. Floyd's Algorithm Variations
    18. Why Floyd's Algorithm Works

  6. Merge Intervals Pattern

    1. 1. Merge Overlapping Intervals Pattern
    2. Example: Merge overlapping intervals
    3. 2. Insert Interval Optimization
    4. Example: Insert interval into sorted intervals
    5. 3. Interval Intersection Logic
    6. Example: Interval list intersections (two sorted lists)
    7. 4. Meeting Rooms Scheduling Problem
    8. Example: Can attend all meetings?
    9. Example: Minimum meeting rooms needed
    10. Example: Meeting rooms II with min heap (alternative)
    11. 5. Non-overlapping Intervals Greedy Approach
    12. Example: Minimum number of intervals to remove
    13. Example: Maximum non-overlapping intervals (activity selection)
    14. 6. Timeline Event Processing Pattern
    15. Example: Employee free time (flatten and find gaps)
    16. Example: Sweep line for maximum concurrent events
    17. Merge Intervals Pattern Summary

  7. Cyclic Sort Pattern

    1. 1. Place Elements in Correct Index
    2. Example: Cyclic sort for range [1, n]
    3. Example: Cyclic sort for range [0, n-1]
    4. 2. Find Missing Numbers O(n) Time
    5. Example: Find missing number (single)
    6. Example: Find all missing numbers
    7. 3. Find Duplicates O(1) Space Complexity
    8. Example: Find duplicate number
    9. Example: Find all duplicates
    10. Example: Find duplicates without modification (index marking)
    11. 4. Corrupt Pairs Detection Pattern
    12. Example: Find corrupt pair (set mismatch)
    13. 5. First Missing Positive Integer Problem
    14. Example: First missing positive integer
    15. 6. Range Validation Techniques
    16. Example: Safe cyclic sort with validation
    17. Example: Validation for edge cases
    18. Cyclic Sort Pattern Summary

  8. Top K Elements Pattern (Heap and QuickSelect)

    1. 1. Kth Largest Element (QuickSelect Algorithm)
    2. Example: Kth largest using min heap
    3. Example: Kth largest using QuickSelect
    4. 2. K Closest Points to Origin
    5. Example: K closest points using max heap
    6. 3. Top K Frequent Elements (HashMap + Heap)
    7. Example: K frequent using min heap
    8. Example: K frequent using bucket sort
    9. 4. QuickSelect Partition Algorithm O(n) Average
    10. Example: QuickSelect with random pivot
    11. Example: QuickSelect with median-of-3 pivot
    12. 5. Merge K Sorted Lists (Min Heap)
    13. Example: Merge K sorted lists
    14. Example: K pairs with smallest sums
    15. 6. Bucket Sort for Top K Elements
    16. Example: Top K frequent using bucket sort
    17. Example: Sort characters by frequency using buckets
    18. Top K Elements Pattern Summary

  9. BFS and DFS Graph Traversal

    1. 1. Level Order Traversal (Queue-based BFS)
    2. Example: Binary tree level order traversal
    3. Example: Graph level order BFS
    4. Example: Right side view of tree
    5. 2. Multi-source BFS Pattern
    6. Example: Rotting oranges (multi-source BFS)
    7. Example: 0-1 matrix (distance to nearest 0)
    8. 3. Shortest Path in Unweighted Graph (BFS)
    9. Example: Shortest path in unweighted graph
    10. Example: Word ladder (shortest transformation)
    11. 4. Cycle Detection Using DFS (Graph Coloring)
    12. Example: Detect cycle in directed graph (DFS coloring)
    13. Example: Course schedule (cycle detection)
    14. 5. Bidirectional BFS Optimization
    15. Example: Bidirectional BFS for shortest path
    16. 6. DFS Iterative Implementation (Stack)
    17. Example: DFS recursive
    18. Example: DFS iterative with stack
    19. Example: DFS iterative with pre/post-order tracking
    20. 7. Flood Fill Algorithm Pattern
    21. Example: Flood fill DFS
    22. Example: Flood fill BFS
    23. Example: Number of islands (flood fill variant)
    24. BFS DFS Graph Traversal Summary

  10. Backtracking Pattern

    1. 1. Generate All Subsets (Powerset)
    2. Example: Subsets using backtracking
    3. Example: Subsets using bit manipulation
    4. Example: Subsets with duplicates
    5. 2. Permutations and Next Lexicographic Order
    6. Example: Permutations using backtracking
    7. Example: Permutations with swap
    8. Example: Next lexicographic permutation
    9. 3. N-Queens Problem Solution
    10. Example: N-Queens solution
    11. Example: N-Queens count only
    12. 4. Sudoku Solver Backtracking
    13. Example: Sudoku solver
    14. 5. Combination Sum Problem
    15. Example: Combination sum (unlimited reuse)
    16. Example: Combination sum II (use once)
    17. 6. Word Search in 2D Grid (DFS Backtracking)
    18. Example: Word search in grid
    19. Example: Word search II (multiple words with Trie)
    20. 7. Palindrome Partitioning Problem
    21. Example: Palindrome partitioning
    22. Example: Palindrome partitioning with DP optimization
    23. Backtracking Pattern Summary

  11. Divide and Conquer Pattern

    1. 1. Merge Sort Algorithm O(n log n)
    2. Example: Merge sort implementation
    3. Example: Count inversions using merge sort
    4. 2. Quick Sort Partition Strategy
    5. Example: Quick sort with Lomuto partition
    6. Example: Quick sort with Hoare partition
    7. Example: 3-way partition (Dutch National Flag)
    8. 3. Binary Tree Divide and Conquer
    9. Example: Tree height/depth
    10. Example: Balanced binary tree
    11. Example: Binary tree diameter
    12. Example: Lowest common ancestor (LCA)
    13. 4. Closest Pair of Points Problem
    14. Example: Closest pair of points
    15. 5. Maximum Subarray (Divide and Conquer)
    16. Example: Maximum subarray divide and conquer
    17. 6. Karatsuba Multiplication Algorithm
    18. Example: Karatsuba multiplication
    19. Example: String-based Karatsuba for very large numbers
    20. Divide and Conquer Summary

  12. Recursion Patterns

    1. 1. Tree Recursion Patterns
    2. Example: Binary tree recursion
    3. Example: N-ary tree recursion
    4. Example: Tree recursion with return value
    5. 2. Tail Recursion Optimization
    6. Example: Non-tail recursive factorial
    7. Example: Tail recursive factorial
    8. Example: Converting to iterative (guaranteed O(1) space)
    9. 3. Recursion Tree Complexity Analysis
    10. Example: Fibonacci recursion tree analysis
    11. Example: Master Theorem applications
    12. 4. Memoization (Top-Down DP)
    13. Example: Fibonacci with memoization
    14. Example: Climbing stairs memoized
    15. Example: Longest increasing subsequence (LIS) memoized
    16. 5. Recursive Data Structures
    17. Example: Recursive linked list operations
    18. Example: Recursive tree construction
    19. 6. Mutual Recursion Patterns
    20. Example: Even/odd mutual recursion
    21. Example: Expression parser mutual recursion
    22. Example: State machine mutual recursion
    23. Recursion Patterns Summary

  13. Dynamic Programming (DP) Patterns

    1. 1. 0/1 Knapsack Problem (Space Optimization)
    2. Example: 0/1 Knapsack 2D DP
    3. Example: 0/1 Knapsack 1D optimized
    4. Example: Partition equal subset sum (0/1 knapsack variant)
    5. 2. Unbounded Knapsack (Bottom-Up DP)
    6. Example: Unbounded knapsack
    7. Example: Coin change (ways to make amount)
    8. Example: Rod cutting problem
    9. 3. Longest Common Subsequence (LCS Algorithm)
    10. Example: Longest common subsequence
    11. Example: LCS with path reconstruction
    12. Example: Space-optimized LCS O(min(m,n))
    13. 4. Longest Increasing Subsequence (LIS O(n log n))
    14. Example: LIS with O(n²) DP
    15. Example: LIS with binary search O(n log n)
    16. Example: LIS with reconstruction
    17. 5. Coin Change Minimum Coins Problem
    18. Example: Coin change minimum coins
    19. Example: Coin change with path
    20. Example: Coin change II (count ways)
    21. 6. Palindromic Substrings (Expand Around Centers)
    22. Example: Count palindromic substrings
    23. Example: Longest palindromic substring
    24. Example: Palindromic substrings DP approach
    25. 7. Edit Distance (Levenshtein Distance Algorithm)
    26. Example: Edit distance (Levenshtein distance)
    27. Example: Space-optimized edit distance
    28. Example: One edit distance
    29. 8. Maximum Subarray Sum (Kadane's Algorithm)
    30. Example: Kadane's algorithm
    31. Example: Kadane with indices
    32. Example: Circular array maximum subarray
    33. 9. House Robber Problem (DP State Transitions)
    34. Example: House robber I
    35. Example: House robber II (circular)
    36. Example: House robber III (binary tree)
    37. 1. 0/1 Knapsack Problem (Space Optimization)
    38. Example: Binary tree diameter
    39. Example: Binary tree maximum path sum
    40. Example: Count good nodes in tree
    41. 1. 0/1 Knapsack Problem (Space Optimization)
    42. Example: Traveling salesman problem (TSP)
    43. Example: Minimum cost to connect all points (Steiner tree)
    44. Example: Partition into k equal sum subsets
    45. 1. 0/1 Knapsack Problem (Space Optimization)
    46. Example: Matrix chain multiplication
    47. Example: Burst balloons
    48. Example: Palindrome partitioning II

  14. Greedy Algorithm Patterns

    1. 1. Activity Selection Problem (Interval Scheduling)
    2. Example: Activity Selection
    3. 2. Jump Game Reachability Problem
    4. Example: Jump Game I - Can Reach End
    5. Example: Jump Game II - Minimum Jumps
    6. 3. Gas Station Problem (Circular Array)
    7. Example: Gas Station Circuit
    8. 4. Interval Scheduling Maximization
    9. Example: Minimum Interval Removals
    10. Example: Minimum Meeting Rooms
    11. 5. Job Sequencing with Deadlines
    12. Example: Job Sequencing Problem
    13. Example: Job Sequencing with Disjoint Set (Optimized)
    14. 6. Greedy Choice Property Proof
    15. Example: Proving Greedy Choice - Fractional Knapsack
    16. When Greedy Works
    17. Example: Huffman Coding (Greedy Correctness)
    18. Summary: Greedy Algorithm Pattern

  15. Bit Manipulation and Bitwise Operations

    1. 1. Bitmasking for Subset Enumeration
    2. Example: Generate All Subsets Using Bitmask
    3. 2. Generate All Subsets Using Bits
    4. Example: Iterate All Submasks of a Mask
    5. Example: DP with Bitmask - Traveling Salesman Problem
    6. 3. Counting Set Bits (Brian Kernighan's Algorithm)
    7. Example: Brian Kernighan's Algorithm
    8. Example: Count Bits for All Numbers 0 to n (DP)
    9. 4. XOR Patterns (Single Number Problem)
    10. Example: Single Number - Find Unique Element
    11. Example: Single Number II - Element Appears Thrice
    12. Example: Single Number III - Two Unique Elements
    13. 5. Bit Manipulation Tricks and Fast Operations
    14. Example: Common Bit Tricks
    15. Example: Fast Modulo and Multiplication
    16. 6. Hamming Distance (Bit Difference Count)
    17. Example: Hamming Distance Between Two Numbers
    18. Example: Total Hamming Distance of Array
    19. 7. Check Power of Two Using Bits
    20. Example: Power of Two Variations
    21. Example: Find Missing Power of Two
    22. 8. Gray Code Generation Algorithm
    23. Example: Generate Gray Code Sequence
    24. Example: Gray Code Conversion
    25. 9. Gosper's Hack (Next Combination with Same Set Bits)
    26. Example: Gosper's Hack - Enumerate k-Combinations
    27. Example: Apply Gosper's Hack to Array
    28. 1. Bitmasking for Subset Enumeration
    29. Example: Reverse 32-bit Integer
    30. Example: Bit Reversal Variants
    31. Summary: Bit Manipulation Pattern

  16. Matrix Traversal and Grid Problems

    1. 1. Spiral Matrix Traversal Pattern
    2. Example: Spiral Matrix Traversal
    3. Example: Generate Spiral Matrix
    4. 2. Search in 2D Sorted Matrix (Staircase Algorithm)
    5. Example: Search in Row and Column Sorted Matrix
    6. Example: Search in Fully Sorted Matrix (2D Binary Search)
    7. Staircase Search Visualization
    8. 3. Number of Islands (DFS/BFS)
    9. Example: Number of Islands (DFS)
    10. Example: Number of Islands (BFS)
    11. Example: Max Area of Island
    12. 4. Rotate Matrix 90 Degrees In-place
    13. Example: Rotate Matrix 90° Clockwise
    14. Example: Rotate 90° Counter-Clockwise
    15. Example: Layer-by-Layer Rotation
    16. Rotation Formulas
    17. 5. Shortest Path in Grid (A* Algorithm)
    18. Example: Shortest Path in Binary Grid (BFS)
    19. Example: A* Search with Manhattan Heuristic
    20. 6. Diagonal Traversal of Matrix
    21. Example: Diagonal Traversal (Zigzag)
    22. Example: Process All Diagonals
    23. Example: Check Diagonal and Anti-Diagonal Sums
    24. Summary: Matrix Traversal Pattern

  17. String Matching and Pattern Search

    1. 1. Longest Substring Without Repeating Characters
    2. Example: Longest Substring Without Repeating Characters
    3. Example: Alternative Using Set
    4. 2. Longest Palindromic Substring (Manacher's Algorithm)
    5. Example: Expand Around Center
    6. Example: Manacher's Algorithm (Linear Time)
    7. 3. Minimum Window Substring (Sliding Window)
    8. Example: Minimum Window Substring
    9. Example: Simplified Version with Character Array
    10. Window Validity Criteria
    11. 4. Group Anagrams Pattern
    12. Example: Group Anagrams Using Sorted Key
    13. Example: Using Character Count as Key
    14. Example: Related Problems - Valid Anagram
    15. 5. String Permutation in String Check
    16. Example: Check Permutation in String
    17. Example: Generate All Permutations
    18. 6. Longest Repeating Character Replacement Problem
    19. Example: Longest Repeating Character Replacement
    20. Example: Alternative with Explicit Max Count Update
    21. Summary: String Matching Pattern

  18. Monotonic Stack and Queue Patterns

    1. 1. Next Greater Element (Stack Pattern)
    2. Example: Next Greater Element
    3. Example: Next Greater Element II (Circular Array)
    4. Example: Next Greater Element I (Subset Problem)
    5. 2. Next Smaller Element Pattern
    6. Example: Next Smaller Element
    7. Monotonic Stack Patterns
    8. 3. Largest Rectangle in Histogram
    9. Example: Largest Rectangle in Histogram
    10. Example: Using Previous and Next Smaller Arrays
    11. Example: Maximal Rectangle in Binary Matrix
    12. 4. Sliding Window Maximum (Deque)
    13. Example: Sliding Window Maximum Using Deque
    14. Example: Min and Max in Sliding Window
    15. 5. Stock Span Problem
    16. Example: Stock Span
    17. Example: Online Stock Span (Class Design)
    18. 6. Trapping Rain Water Problem
    19. Example: Trapping Rain Water (Two Pointers)
    20. Example: Trapping Rain Water (Monotonic Stack)
    21. Example: Trapping Rain Water II (2D Grid)
    22. Summary: Monotonic Stack Queue Pattern

  19. Line Sweep and Scanline Pattern

    1. 1. Interval Merging Using Sweep Line
    2. Example: Merge Overlapping Intervals
    3. Example: Insert Interval
    4. 2. Meeting Rooms with Multiple Events
    5. Example: Meeting Rooms I - Can Attend All
    6. Example: Meeting Rooms II - Minimum Rooms
    7. Example: Employee Free Time
    8. 3. Skyline Problem (Event Points)
    9. Example: Skyline Problem
    10. 4. Rectangle Overlap Detection
    11. Example: Rectangle Overlap (2 Rectangles)
    12. Example: Rectangle Area (Union of Two Rectangles)
    13. Example: Rectangle Area II (Union of Multiple Rectangles)
    14. 5. Event-driven Processing Pattern
    15. Example: Task Scheduler with Cooldown
    16. Example: Car Fleet (Event-driven)
    17. Example: The Earliest Moment When Everyone Becomes Friends
    18. Summary: Line Sweep Scanline Pattern

  20. Meet in the Middle Pattern

    1. 1. Two Array Sum Combination Problem
    2. Example: Find if subset sum equals target using two arrays
    3. 2. Subset Sum Using Split Search
    4. Example: Count number of subsets with given sum
    5. 3. Closest Subset Sum Problem
    6. Example: Find subset sum closest to target
    7. 4. 4Sum Problem Optimization
    8. Example: 4Sum using Meet in the Middle
    9. Example: 4Sum using Two Pointers (Optimal)
    10. 5. Exponential to Polynomial Time Reduction
    11. Example: Partition array into two subsets with minimum difference
    12. Example: Comparison of complexities
    13. Summary: Meet in the Middle Pattern

  21. Square Root Decomposition (Sqrt Decomposition)

    1. 1. Range Query Using Block Division
    2. Example: Range sum query with updates
    3. 2. Mo's Algorithm (Query Ordering)
    4. Example: Mo's Algorithm - Distinct elements in ranges
    5. 3. Update vs Query Time Trade-off
    6. Example: Range minimum with updates
    7. Complexity Comparison
    8. 4. Sqrt Decomposition on Arrays
    9. Example: Range GCD queries
    10. 5. Block-wise Processing Pattern
    11. Example: Range add with lazy propagation
    12. Example: Mo's Algorithm with modifications
    13. Summary: Square Root Decomposition Pattern

  22. Linked List Manipulation Patterns

    1. 1. Reverse Linked List (Iterative and Recursive)
    2. Example: Iterative reversal
    3. Example: Recursive reversal
    4. Example: Reverse sublist [m, n]
    5. 2. Merge Two Sorted Linked Lists
    6. Example: Merge iterative with dummy
    7. Example: Merge recursive
    8. 3. Remove Nth Node From End of List
    9. Example: Remove Nth from end (one pass)
    10. 4. Reorder Linked List Pattern
    11. Example: Reorder list (L0→Ln→L1→Ln-1...)
    12. 5. Copy List with Random Pointer (Deep Copy)
    13. Example: Copy using hash map
    14. Example: Copy with O(1) space (interleaving)
    15. 6. Flatten Multilevel Doubly Linked List
    16. Example: Flatten doubly linked list with child pointer
    17. Example: Flatten recursive approach
    18. Summary: Linked List Manipulation Patterns

  23. Tree Traversal Patterns

    1. 1. Morris Inorder Traversal O(1) Space
    2. Example: Morris inorder traversal
    3. Example: Morris preorder and postorder
    4. 2. Level Order Traversal Bottom-Up
    5. Example: Bottom-up level order (BFS + reverse)
    6. Example: Bottom-up using DFS
    7. 3. Vertical Order Traversal of Binary Tree
    8. Example: Vertical order traversal with sorting
    9. 4. Boundary Traversal of Binary Tree
    10. Example: Binary tree boundary traversal
    11. 5. Zigzag Level Order Traversal
    12. Example: Zigzag with BFS and reverse
    13. Example: Zigzag with two stacks
    14. 6. Serialize and Deserialize Binary Tree
    15. Example: Serialize/deserialize with preorder
    16. Example: Serialize/deserialize with BFS
    17. Summary: Tree Traversal Patterns

  24. Modified Binary Search Patterns

    1. 1. Search in 2D Matrix (Binary Search)
    2. Example: Search in fully sorted 2D matrix
    3. Example: Search in row/col sorted matrix
    4. 2. Find Peak Element Problem
    5. Example: Find peak element
    6. 3. Search in Rotated Sorted Array
    7. Example: Search in rotated sorted array
    8. 4. Find Minimum in Rotated Sorted Array
    9. Example: Find minimum (no duplicates)
    10. Example: Find minimum (with duplicates)
    11. 5. Search Insert Position in Array
    12. Example: Search insert position (lower bound)
    13. Example: Lower and upper bound templates
    14. 6. Find First and Last Position in Sorted Array
    15. Example: Find first and last position
    16. Example: Using lower/upper bound approach
    17. Summary: Modified Binary Search Patterns

  25. In-place Reversal of Linked List

    1. 1. Reverse Linked List In-place O(1) Space
    2. Example: Reverse entire linked list iteratively
    3. 2. Reverse Linked List Sublist Pattern
    4. Example: Reverse between positions m and n
    5. 3. Reverse Nodes in K-Group
    6. Example: Reverse nodes in k-group
    7. Example: Reverse k-group iteratively
    8. 4. Rotate Linked List Pattern
    9. Example: Rotate list right by k places
    10. 5. Swap Nodes in Pairs (Linked List)
    11. Example: Swap pairs iteratively
    12. Example: Swap pairs recursively
    13. Example: General swap every k nodes
    14. Summary: In-place Reversal Patterns

  26. Subsets and Combinations Patterns

    1. 1. Generate All Subsets (Powerset)
    2. Example: Backtracking approach
    3. Example: Iterative build approach
    4. Example: Bit manipulation approach
    5. 2. Subsets with Duplicate Elements
    6. Example: Subsets with duplicates
    7. 3. Combinations of K Elements
    8. Example: Combinations C(n, k)
    9. Example: Pascal's triangle approach
    10. 4. Combination Sum Problem Variations
    11. Example: Combination Sum I (unlimited reuse)
    12. Example: Combination Sum II (each once, has duplicates)
    13. Example: Combination Sum IV (order matters - DP)
    14. 5. Letter Combinations of Phone Number
    15. Example: Backtracking approach
    16. Example: Iterative build approach
    17. Example: BFS queue approach
    18. Summary: Subsets and Combinations Patterns

  27. Topological Sort Pattern

    1. 1. Course Schedule Problem (Kahn's Algorithm)
    2. Example: DFS cycle detection
    3. Example: Kahn's algorithm (BFS)
    4. Example: Course Schedule II - return topological order
    5. 2. Alien Dictionary Problem (Character Order)
    6. Example: Alien dictionary character order
    7. 3. Build Order with Dependencies
    8. Example: Lexicographically smallest topological order
    9. Example: Group by parallel execution levels
    10. 4. All Topological Orderings of DAG
    11. Example: Generate all topological orderings
    12. 5. Sequence Reconstruction Verification
    13. Example: Verify sequence reconstruction
    14. Example: Alternative - check pairs coverage
    15. Summary: Topological Sort Patterns

  28. Interval Scheduling Patterns

    1. 1. Minimum Meeting Rooms Required
    2. Example: Min heap approach
    3. Example: Chronological ordering
    4. Example: Sweep line with events
    5. 2. Employee Free Time Problem
    6. Example: Flatten and merge approach
    7. Example: Priority queue k-way merge
    8. 3. Interval List Intersections
    9. Example: Two pointers intersection
    10. Example: Visualizing intersection logic
    11. 4. Insert Interval and Merge
    12. Example: Insert and merge interval
    13. Example: Alternative approach with three passes
    14. 5. Task Scheduler Problem (Greedy)
    15. Example: Greedy formula approach
    16. Example: Heap simulation approach
    17. Summary: Interval Scheduling Patterns

  29. Parentheses and Bracket Patterns

    1. 1. Valid Parentheses Using Stack
    2. Example: Stack-based validation
    3. Example: Cleaner with early returns
    4. Example: Optimized for single bracket type
    5. 2. Generate Parentheses (Backtracking)
    6. Example: Backtracking generation
    7. Example: Alternative with explicit tracking
    8. 3. Longest Valid Parentheses (DP Solution)
    9. Example: DP approach
    10. Example: Stack approach
    11. Example: Two-pass O(1) space
    12. 4. Remove Invalid Parentheses (BFS)
    13. Example: BFS with early termination
    14. Example: Backtracking with counting
    15. 5. Minimum Add to Make Valid Parentheses
    16. Example: Counter approach
    17. Example: Balance tracking
    18. Example: Related problem - make valid with moves
    19. Summary: Parentheses Problems Patterns

  30. Reservoir Sampling Pattern

    1. 1. Random Pick from Stream (Reservoir Sampling)
    2. Example: Single item reservoir sampling
    3. Example: Alternative with random index
    4. 2. Random Node from Linked List
    5. Example: Reservoir sampling approach
    6. Example: Array conversion approach
    7. 3. Random Pick with Weight (Weighted Sampling)
    8. Example: Prefix sum with binary search
    9. Example: Visualizing the probability distribution
    10. 4. Shuffle Array (Fisher-Yates Algorithm)
    11. Example: Fisher-Yates shuffle
    12. Example: Forward version
    13. Example: Shuffle class for reset functionality
    14. 5. Sample K Items Uniformly from Stream
    15. Example: Reservoir sampling for k items
    16. Example: Partial Fisher-Yates
    17. Example: Optimized with index set
    18. Summary: Reservoir Sampling Patterns

  31. Rolling Hash Pattern (Rabin-Karp)

    1. 1. Rabin-Karp String Matching Pattern
    2. Example: Rabin-Karp pattern matching
    3. Example: Simplified rolling hash update
    4. 2. Repeated DNA Sequences Problem
    5. Example: Rolling hash approach
    6. Example: Bit encoding optimization
    7. 3. Longest Duplicate Substring Problem
    8. Example: Binary search with rolling hash
    9. 4. Find All Anagrams in String
    10. Example: Frequency array sliding window
    11. Example: Optimized with match counter
    12. 5. Polynomial Rolling Hash Function
    13. Example: Double hash to reduce collisions
    14. Example: Polynomial hash implementation details
    15. Summary: Rolling Hash Patterns

  32. Game Theory Patterns

    1. 1. Minimax Algorithm Pattern
    2. Example: Basic minimax for Tic-Tac-Toe
    3. 2. Alpha-Beta Pruning Optimization
    4. Example: Minimax with alpha-beta pruning
    5. Example: Alpha-beta pruning visualization
    6. 3. Nim Game Problem Pattern
    7. Example: Simple Nim game - remove 1, 2, or 3 stones
    8. 4. Stone Game (DP Solution)
    9. Example: Stone game - take first or last
    10. Example: Stone game with prefix sum optimization
    11. 5. Predict the Winner Problem
    12. Example: Predict winner with DP
    13. Example: Space-optimized and memoization
    14. Summary: Game Theory Patterns

  33. Design and Data Structure Patterns

    1. 1. LRU Cache (HashMap + Doubly Linked List)
    2. Example: LRU Cache implementation
    3. 2. LFU Cache (Frequency Tracking)
    4. Example: LFU Cache implementation
    5. 3. Min Stack with O(1) Operations
    6. Example: Two stacks approach
    7. Example: Optimized min stack
    8. 4. Implement Queue Using Stacks
    9. Example: Queue using two stacks
    10. 5. Design Twitter Timeline (OOD)
    11. Example: Twitter timeline with merge k lists
    12. 6. Design Hit Counter Problem
    13. Example: Queue-based hit counter
    14. Example: Circular array (O(1) space)
    15. Summary: Design Pattern Problems

  34. Multi-threading and Concurrency Patterns

    1. 1. Producer-Consumer Pattern (Concurrency)
    2. Example: Producer-Consumer with bounded buffer
    3. 2. Print in Order Problem (Thread Synchronization)
    4. Example: Print in order using semaphores
    5. Example: Using promises in JavaScript
    6. 3. Dining Philosophers Problem
    7. Example: Dining philosophers with resource ordering
    8. Example: Waiter solution (limit concurrent diners)
    9. 4. Reader-Writer Lock Pattern
    10. Example: Readers-preference lock
    11. Example: Fair reader-writer lock
    12. 5. Traffic Light Controller System
    13. Example: Traffic light synchronization
    14. Example: Advanced traffic light with priorities
    15. Summary: Multi-threading Patterns

  35. Common Pitfalls and Edge Cases

    1. 1. Integer Overflow Handling Techniques
    2. Example: Detecting overflow before operation
    3. Example: Common overflow scenarios
    4. 2. Floating Point Precision Errors
    5. Example: Floating point comparison
    6. Example: Common floating point pitfalls
    7. 3. Array Index Out of Bounds Errors
    8. Example: Array bounds checking patterns
    9. 4. Null Pointer Safety Checks
    10. Example: Null/undefined safety patterns
    11. Example: Defensive programming
    12. 5. Stack Overflow from Recursion Depth
    13. Example: Stack overflow scenarios
    14. Example: Converting recursion to iteration
    15. 6. Off-by-One Errors Prevention
    16. Example: Common off-by-one mistakes
    17. Example: Edge case testing for off-by-one
    18. 7. Empty Input Validation
    19. Example: Empty input handling
    20. 8. Single Element Edge Cases
    21. Example: Single element handling
    22. Example: Testing with minimal inputs
    23. 9. Duplicate Handling Strategies
    24. Example: Various duplicate handling approaches
    25. Example: Duplicate detection patterns
    26. 1. Integer Overflow Handling Techniques
    27. Example: Overflow prevention techniques
    28. Summary: Common Pitfalls and Edge Cases

  36. Testing and Debugging Strategies

    1. 1. Test Case Generation Strategies
    2. Example 1: Test Case Generator for Sorting Function
    3. Example 2: Automated Test Case Generator with Coverage
    4. 2. Edge Case Identification Techniques
    5. Example 1: Comprehensive Edge Case Checker
    6. 3. Boundary Value Testing
    7. Example 1: Boundary Value Test Generator
    8. 4. Performance Profiling and Optimization
    9. Example 1: Performance Profiler with Time Complexity Verification
    10. 5. Algorithm Code Review Checklist
    11. Example 1: Automated Code Review Checker
    12. 6. Stress Testing with Large Inputs
    13. Example 1: Stress Test Framework
    14. 7. Corner Case Enumeration Methods
    15. Example: Corner Case Generator and Validator
    16. Summary: Testing and Debugging Patterns