Patterns Directory

Use two pointers moving through data (often from opposite ends) to solve problems efficiently without extra space.

Use pointers moving at different speeds (typically 1x and 2x) to detect cycles or find specific positions.

Maintain a window of elements that satisfies certain conditions, expanding and contracting as needed.

Sort intervals by start time and merge overlapping ones by tracking the maximum end time.

Modify linked list structure without extra data structures by manipulating pointers.

Use min-heap or max-heap to efficiently track and access minimum or maximum elements.

Merge K sorted lists efficiently using a min-heap of pointers to track the smallest current element.

Find K largest or smallest elements using partial sorting via heap, avoiding full sort.

Eliminate half of search space each iteration on sorted data to find target efficiently.

Adapt binary search for rotated arrays, special conditions, or finding peaks and boundaries.

Generate all combinations using include/exclude decisions or BFS approach.

Explore all possibilities, pruning invalid branches early to avoid unnecessary exploration.

Make locally optimal choices at each step that lead to global optimum (with proof).

Solve overlapping subproblems by storing results and combining them (memoization or tabulation).

Place each number at its correct index in range 1-n to find missing/duplicate in O(n) time.

Order vertices in DAG based on dependencies using DFS or Kahn's algorithm (remove 0-indegree).

Tree-based structure for storing strings, enabling efficient prefix-based searches and autocomplete.

Store key-value pairs with O(1) average lookup to count frequencies and track elements.

Track connected components and merge sets efficiently with path compression and union by rank.

Operate on individual bits using AND, OR, XOR, NOT for space-efficient solutions.

Apply mathematical formulas, number theory, and coordinate geometry for problem-solving.

Recursively traverse tree going deep on one branch before backtracking (inorder/preorder/postorder).

Process tree level-by-level using queue, useful for shortest paths and level-order processing.

General graph traversal using DFS (recursion/stack) or BFS (queue) to explore all nodes.

Operate on 2D grids including rotations, spirals, and multi-directional traversals.

LIFO structure for managing call stacks, matching parentheses, or maintaining monotonic order.

Combine existing structures (hash map, linked list, heap) to optimize for specific operations.