When should you use return in recursive algorithms? The answer depends entirely on whether your function needs to produce a value that gets passed back up the call stack.

Two classic examples illustrate this distinction: binary search and quicksort.

Binary Search: return Required

Binary search must propagate a result back to the caller. When an element is found, that position travels back through every recursive call until it reaches the original invocation.

def binary_search(collection, left, right, target):
    if right < left:
        return -1

    middle = (left + right) // 2

    if collection[middle] == target:
        return middle
    elif collection[middle] > target:
        return binary_search(collection, left, middle - 1, target)
    else:
        return binary_search(collection, middle + 1, right, target)

Every recusrive call includes return. Without it, the function would return None implicitly, and the calling function would never receive the index it needs. The return statement carries the result upward through the chain of recursive calls.

Quicksort: No return Neeeded in Recursive Calls

Quicksort operates differently. It mutates the list in place and does not need to pass data back through the recursion. Each recursive call handles a subarrray, modifies the shared data structure, and the final result is already available where it was originally created.

def quicksort(arr, low, high):
    if low < high:
        pivot_index = partition(arr, low, high)
        quicksort(arr, low, pivot_index - 1)
        quicksort(arr, pivot_index + 1, high)
    return arr

The recursive invocations to quicksort do not need return because:

1. The function modifies the array in place, so all changes persist automatically
2. The final return arr is unnecessary if the caller does not expect a return value
3. Both recursive calls operate on the same list object, so the sorted result propagates without explicit return statements

The Core Principle

The decision to use return in recursive functions follows a simple rule: if a value must travel back up the call stack, use return. If the function only performs side effects or modifies shared state, return becomes optional at the recursive level.

Binary search needs values back, so every call returns. Quicksort modifies global state, so recursive calls can omit return statements.

Understanding what your function needs to accomplish determines whether return belongs in your recursive cases.