Searching & Recursion
Master searching algorithms and recursive problem-solving — binary search variations, recursion patterns, and backtracking.
50 min•By Priygop Team•Last updated: Feb 2026
Searching Algorithms
- Linear Search: Check each element sequentially. O(n). Works on unsorted arrays. Use when array is small or unsorted
- Binary Search: Requires sorted array. Compare target with middle element, eliminate half each time. O(log n). Powerful for sorted data and answer-space problems
- Binary Search Variations: Find first/last occurrence (continue searching after finding target), find floor/ceiling, search in rotated sorted array, find peak element
- Interpolation Search: Like binary search but estimates position based on value distribution. O(log log n) for uniformly distributed data. O(n) worst case
- Two Pointer Technique: Two indices moving toward each other — find pair with given sum in sorted array, remove duplicates, container with most water
- Sliding Window: Fixed or variable-size window over array — maximum sum subarray, longest substring without repeating characters. O(n) linear scan
Recursion & Backtracking
- Recursion Fundamentals: Base case (stopping condition) + recursive case (break into smaller subproblems). Each recursive call uses stack space — deep recursion can cause stack overflow
- Tail Recursion: Recursive call is the last operation — compiler can optimize to loop (tail call optimization). int factorial(int n, int acc) { return n <= 1 ? acc : factorial(n-1, n*acc); }
- Divide and Conquer: Split problem into independent subproblems, solve each, combine results. Examples: merge sort, quick sort, binary search, matrix multiplication
- Backtracking: Try a choice, recurse, undo the choice if it leads to dead end. Solves: N-Queens, Sudoku solver, maze navigation, generating permutations/combinations
- Memoization: Cache results of expensive recursive calls — use array or hash table. Fibonacci without memo: O(2^n). With memo: O(n). Foundation for dynamic programming
- Tower of Hanoi: Classic recursion problem — move n disks from source to destination using auxiliary peg. Solution requires 2^n - 1 moves. Beautiful recursive decomposition