Multiplicative Recursion

Multiplicative recursion builds a product by combining one factor at each level of recursion. Factorial multiplies n by (n - 1)!; power multiplies base by base^(exp - 1). Each return value carries the partial product upward.

The base case usually returns 1, because 1 is the multiplicative identity — multiplying by 1 doesn't change the running product.

On the AP exam, factorial is the canonical first recursion FRQ, and power is its near-twin.

Factorial

public int factorial(int n) {
    if (n <= 1) return 1;            // base case
    return n * factorial(n - 1);     // multiply n by smaller factorial
}

The recursive case multiplies n by the result of factorial(n - 1). The base case returns 1 because 0! = 1 and 1! = 1 by convention.

Power

public int power(int base, int exp) {
    if (exp == 0) return 1;
    return base * power(base, exp - 1);
}

Each call peels off one factor of base. The exponent counts down toward 0.

Return-value propagation

Each call multiplies its factor by what the smaller call returns. The returns "bubble up" the stack: the innermost call (base case) returns 1, then the next level multiplies that by its factor, then the next, and so on — until the outermost call has the full product.

Why base case returns 1

Returning 0 would zero out the entire product. Returning 1 is the multiplicative identity: x * 1 = x, so multiplying by the base case's return doesn't change the running product. This is the mathematical mirror of the additive base case (0).