Uses two pointers starting from opposite ends of an array or list, moving towards each other. Achieves O(n) time complexity with O(1) space, making it ideal for in-place array manipulation and searching in sorted sequences.

Maintains a window of elements that slides through the array, either fixed or variable size. Efficiently solves substring and subarray problems by avoiding redundant computations, achieving O(n) time complexity.

Uses two pointers moving at different speeds through a data structure. The fast pointer moves twice as fast as the slow pointer, enabling cycle detection and finding middle elements with O(n) time and O(1) space.

Recursive approach that stores computed results to avoid redundant calculations. Easier to conceptualize and implement, follows natural problem decomposition. Trade-off is additional space for recursion stack and memoization cache.

Iterative approach that builds solutions from base cases upward. Generally more space-efficient and faster than top-down due to no recursion overhead. Requires careful consideration of iteration order and dependencies.

Models problems as state transitions where each state depends on previous states and specific conditions. Excellent for problems with multiple states or phases, like stock trading with buy/sell/cooldown states.

Splits problem into two roughly equal halves, solves recursively, then combines results. Creates O(log n) levels of recursion. Foundation for many efficient algorithms including merge sort and binary search.

Divides problem into multiple parts (not just two). Quick sort and quick select are prime examples, partitioning around a pivot. Provides flexibility in how to split the problem space.

Focus is on merging solutions from divided subproblems. Critical step in divide-and-conquer where partial solutions are combined to form complete solution. Often the most complex part of the algorithm.