Recursion Over an Array by Index

Unlike numbers (which shrink with n - 1) or Strings (which shrink with substring), Java arrays don't have a built-in "smaller array" operation. To recurse over an array, you pass an index parameter that tells the method which position to look at — and recurse with index + 1.

The base case fires when index == arr.length — past the end of the array. That's the stopping condition.

On the AP exam, array recursion always uses this index-parameter pattern.

Why an index parameter?

Java has no built-in way to make a "smaller" array cheaply. You could create a new sub-array each call, but that's wasteful and rarely fits an AP rubric. Instead, the array is passed by reference unchanged, and the index parameter advances each call.

Sum an array

public int arraySum(int[] arr, int index) {
    if (index == arr.length) return 0;          // base case
    return arr[index] + arraySum(arr, index + 1);
}

Caller starts at index 0: arraySum(myArr, 0). Each call adds the current element and recurses on the next index.

Find max

public int findMax(int[] arr, int index) {
    if (index == arr.length - 1) return arr[index];   // last element
    int restMax = findMax(arr, index + 1);
    return Math.max(arr[index], restMax);
}

Base case at the last index returns that element. Each level compares its element with the max of the rest.

Count even values

public int countEven(int[] arr, int index) {
    if (index == arr.length) return 0;
    int restCount = countEven(arr, index + 1);
    if (arr[index] % 2 == 0) return 1 + restCount;
    else return restCount;
}

The recursive case adds 1 only when the current element matches the condition.

Helper-method pattern

In FRQs, the public method often takes just the array and calls a private recursive helper with the index:

public int arraySum(int[] arr) {
    return arraySumHelper(arr, 0);
}
private int arraySumHelper(int[] arr, int index) {
    if (index == arr.length) return 0;
    return arr[index] + arraySumHelper(arr, index + 1);
}

The public method hides the index from the caller.