4.5 Developing Algorithms Using Arrays

TLDR

Implementing array algorithms means writing loops that traverse a 1D array to do a job: find a minimum or maximum, total or average the values, check whether some or all elements match a condition, count matches, compare neighboring pairs, spot duplicates, shift or rotate elements, or reverse the array. These are the standard patterns you build by hand and trace through on the AP Computer Science A exam, so know how each loop moves through indices and what the array looks like when it finishes.

more resources to help you study

practice multiple choiceFRQ practice & scoringcheatsheetsscore calculator

Why This Matters for the AP Computer Science A Exam

Array algorithms show up in both the multiple-choice and free-response sections of the AP Computer Science A exam. On multiple choice, you often trace a traversal to predict the final array or a returned value, so you need to follow index movement carefully. When an array is not fully defined in a question, you can make your own small array and trace the code on it.

In free-response code writing, you develop methods that traverse arrays for a specific purpose, like summing values that meet a condition or returning whether a duplicate exists. The graders care about loops that work for every valid input, not just one example, so your bounds and conditions have to be correct from the first element to the last.

These patterns also build directly into later topics. The same traversal thinking carries over to ArrayList algorithms, 2D array algorithms, and the searching and sorting work later in the unit.

Key Takeaways

• Most array algorithms are a single traversal plus a small amount of bookkeeping, like a running total, a current best value, or a count.
• To find a minimum or maximum, start your candidate at the first element, then compare every other element and update when you find something better.
• Existential checks ("at least one element...") can stop early once you find a match; universal checks ("all elements...") must keep going until something fails.
• Accessing consecutive pairs means comparing array[i] with array[i + 1], so the loop must stop one index early to stay in bounds.
• Shifting, rotating, and reversing move existing values to new positions, so use a temporary variable for swaps and watch your boundary indices.
• Valid indices run from 0 to array.length - 1; stepping outside that range throws an ArrayIndexOutOfBoundsException.

Standard Array Algorithm Patterns

These are the traversal-based patterns you are expected to build and trace. Each one is just a loop over the array with a clear goal.

Minimum or Maximum

Keep a candidate for the extreme value. Start it at the first element, then walk the rest of the array and update whenever you find something better. Tracking the index instead of the value is a common variation, which you need when you plan to move that element later.

</>Java
public static int findMaxIndex(int[] array) {
    int maxIndex = 0;
    for (int i = 1; i < array.length; i++) {
        if (array[i] > array[maxIndex]) {
            maxIndex = i;
        }
    }
    return maxIndex;
}

Sum or Average

Accumulate a running total during the traversal, then divide by array.length for an average. Watch your types: dividing two int values truncates, so cast to double when you need a decimal result.

</>Java
public static double average(int[] array) {
    int sum = 0;
    for (int value : array) {
        sum += value;
    }
    return (double) sum / array.length;
}

Existential and Universal Checks

An existential check answers "does at least one element have this property?" You can return true the moment you find a match. A universal check answers "do all elements have this property?" and must return false as soon as one element fails, returning true only if the loop finishes without a failure.

</>Java
// At least one negative value?
public static boolean hasNegative(int[] array) {
    for (int value : array) {
        if (value < 0) {
            return true;
        }
    }
    return false;
}

// Are all values positive?
public static boolean allPositive(int[] array) {
    for (int value : array) {
        if (value <= 0) {
            return false;
        }
    }
    return true;
}

Counting Elements With a Property

Start a counter at 0 and add 1 each time an element matches the condition. This is the same traversal as an existential check, except you never stop early.

</>Java
public static int countEven(int[] array) {
    int count = 0;
    for (int value : array) {
        if (value % 2 == 0) {
            count++;
        }
    }
    return count;
}

Consecutive Pairs

To compare each element with its neighbor, access array[i] and array[i + 1] in the same iteration. The loop must stop at array.length - 1 so that array[i + 1] stays in bounds.

</>Java
// Counts how many times an element is followed by a larger element
public static int countAscendingPairs(int[] array) {
    int count = 0;
    for (int i = 0; i < array.length - 1; i++) {
        if (array[i] < array[i + 1]) {
            count++;
        }
    }
    return count;
}

Duplicate Detection

To check whether any value repeats, compare each element with the elements after it using nested loops. The outer loop picks an element, and the inner loop checks every later element for a match.

</>Java
public static boolean hasDuplicate(int[] array) {
    for (int i = 0; i < array.length; i++) {
        for (int j = i + 1; j < array.length; j++) {
            if (array[i] == array[j]) {
                return true;
            }
        }
    }
    return false;
}

Shifting and Rotating

Shifting moves every element one position left or right. Rotating is similar, except the value pushed off one end wraps around to the other end. Save the wrapping value before you overwrite it.

</>Java
// Rotate every element one position to the right
public static void rotateRight(int[] array) {
    if (array.length == 0) return;
    int last = array[array.length - 1];
    for (int i = array.length - 1; i > 0; i--) {
        array[i] = array[i - 1];
    }
    array[0] = last;
}

Reversing

Reverse an array in place with two indices that move toward each other, swapping as they go. Stop when they meet in the middle.

</>Java
public static void reverse(int[] array) {
    int start = 0;
    int end = array.length - 1;
    while (start < end) {
        int temp = array[start];
        array[start] = array[end];
        array[end] = temp;
        start++;
        end--;
    }
}

How to Use This on the AP Computer Science A Exam

Code Tracing

For multiple-choice tracing, follow the loop one iteration at a time and write down what changes. Track the loop index and any helper variables like a running sum, a current best value, or a counter. When a question gives code but no specific array, invent a short array of your own, maybe four or five elements, and run the code on it. Pay attention to whether a loop ends at array.length or array.length - 1, since that one difference changes which elements get touched.

Free Response

When you write a method that processes an array, decide first what the loop has to do on each element, then choose your bounds. Use an enhanced for loop when you only need each value and never need its index. Use an indexed for loop when you need the index, when you compare array[i] with array[i + 1], or when you change elements based on position. Make sure your logic is correct for the entire array, including the first and last elements, not just a middle case.

Common Trap

Off-by-one mistakes cause most array algorithm errors. Comparing consecutive pairs while looping to array.length reads past the end and throws an ArrayIndexOutOfBoundsException. Starting a minimum or maximum search at the wrong index, or initializing your candidate badly, gives a wrong answer that still compiles. Trace the very first and very last iterations on paper to confirm your bounds.

Common Misconceptions

• Changing the variable in an enhanced for loop does not change the array. The loop variable holds a copy of each value, so assigning to it has no effect on the stored elements. To change array contents, use an index and write to array[i].
• An average is not automatically a decimal. If you sum int values and divide by an int length, Java does integer division and drops the fraction. Cast to double to keep the decimal part.
• A universal check ("all elements...") cannot return true the first time one element passes. It has to keep checking and can only return true after the whole loop finishes without a failure.
• Reversing or rotating in place still needs a temporary variable for each swap. Assigning one element directly onto another without saving the old value first loses data.
• The last valid index is array.length - 1, not array.length. Using the length itself as an index is out of bounds.
• A bigger array is not what makes an algorithm wrong on the exam. Graders check that your loop works for every valid input, so a solution that only handles one sample array will lose points even if it compiles.

Related AP Computer Science A Guides

• 4.11 2D Arrays
• 4.15 Sorting
• 4.1 Ethical and Social Implications
• 4.9 Traversing ArrayLists
• 4.13 Implementing 2D Array Algorithms
• 4.16 Recursion