Mastering DSA: 5 Patterns that Solve 100+ LeetCode Problems

Introduction

During my final year of computer science, I felt overwhelmed by the sheer number of problems on platforms like LeetCode. However, as I started preparing for corporate technical rounds, I realized that most problems are just variations of a few core patterns.

Instead of memorizing 500 solutions, I focused on mastering these 5 patterns. Here is how they changed my approach to problem-solving.

Sliding Window Pattern

The Sliding Window pattern is used for problems involving arrays or strings where you need to find a sub-segment that meets certain criteria. It reduces complexity from $O(n^2)$ to $O(n)$.

Example: Longest Substring Without Repeating Characters

function lengthOfLongestSubstring(s) {
  let set = new Set()
  let left = 0
  let maxLength = 0

  for (let right = 0; right < s.length; right++) {
    while (set.has(s[right])) {
      set.delete(s[left])
      left++
    }
    set.add(s[right])
    maxLength = Math.max(maxLength, right - left + 1)
  }
  return maxLength
}

Complexity Analysis: $O(n)$ Time, $O(min(m, n))$ Space where $m$ is the size of the charset.

Two Pointers Pattern

When dealing with sorted arrays or linked lists, the Two Pointers pattern is incredibly efficient. It typically uses one pointer at the start and one at the end, or two pointers moving at different speeds.

Example: Valid Palindrome

function isPalindrome(s) {
  let left = 0,
    right = s.length - 1
  while (left < right) {
    if (s[left] !== s[right]) return false
    left++
    right--
  }
  return true
}

Fast and Slow Pointers (Cycle Detection)

Also known as Floyd's Cycle-Finding Algorithm. This uses two pointers that move at different speeds (e.g., one moves 1 step while the other moves 2).

Example: Linked List Cycle

function hasCycle(head) {
  let slow = head
  let fast = head

  while (fast && fast.next) {
    slow = slow.next
    fast = fast.next.next
    if (slow === fast) return true
  }
  return false
}

Breadth First Search (BFS) for Level Order Traversal

BFS is essential for finding the shortest path in unweighted graphs or trees. It uses a Queue to explore neighbors level by level.

Example: Binary Tree Level Order Traversal

function levelOrder(root) {
  if (!root) return []
  let result = []
  let queue = [root]

  while (queue.length > 0) {
    let levelSize = queue.length
    let currentLevel = []
    for (let i = 0; i < levelSize; i++) {
      let node = queue.shift()
      currentLevel.push(node.val)
      if (node.left) queue.push(node.left)
      if (node.right) queue.push(node.right)
    }
    result.push(currentLevel)
  }
  return result
}

Overlapping Subproblems (Dynamic Programming)

Dynamic Programming (DP) is often the most feared topic. However, it's simply recursion + memoization. If a problem can be broken down into subproblems that repeat, DP is the answer.

Example: Climbing Stairs (Fibonacci Variation)

function climbStairs(n) {
  if (n <= 2) return n
  let first = 1
  let second = 2
  for (let i = 3; i <= n; i++) {
    let third = first + second
    first = second
    second = third
  }
  return second
}

Interview Tip: Always start with a recursive solution, then explain how you'd optimize it with a memoization table (Top-Down) or a tabulation array (Bottom-Up).

Conclusion

Shifting from "solving problems" to "identifying patterns" was the single biggest boost to my interview confidence. By mastering these five, you cover nearly 70% of the common questions asked in technical rounds.

What patterns do you find most challenging? Let's discuss in the comments!