Crack your next
technical interview.

Use two index variables that move toward each other or in the same direction to solve array and string problems in linear time.

Maintain a dynamic window of elements over a sequence to track running statistics without recomputing from scratch on every step.

Run two pointers at different speeds to detect cycles in linked lists or find the midpoint without extra space.

Sort intervals by start time, then greedily merge overlapping ones by comparing the current end with the next start.

Place each number directly at its correct index in O(n) time when elements fall in a known range, then scan for misplaced values.

Reverse a linked list or sublist by re-wiring next pointers in a single pass without allocating extra nodes.

Use a queue to visit nodes level by level, making it the natural fit for shortest-path and level-order problems on trees.

Recursively explore each branch to its leaf before backtracking, covering path-sum, tree diameter, and ancestor queries.

Keep a max-heap of lower half and a min-heap of upper half to answer median queries in logarithmic time as data streams in.

Generate all combinations or permutations through backtracking, adding or skipping each element at every recursive level.

Eliminate half the search space each iteration whenever the input is sorted or the answer space is monotonically ordered.

Exploit the self-cancelling property of XOR to find single numbers, missing values, or swap variables without a temp.

Maintain a min-heap of size K so that the smallest seen value is always at the top, giving the K largest in O(n log K).

Use a min-heap seeded with the first element of each sorted list to merge K lists in O(n log K) total time.

Order nodes in a directed acyclic graph so every edge points forward, solving task scheduling and dependency resolution problems.

Break problems into overlapping subproblems, store their solutions, and build the final answer bottom-up or top-down with memoization.