AP CSA: Searching and Sorting — Complete Guide (2025-2026)

Searching and Sorting in AP CSA

The AP exam requires you to implement, trace, and analyze both linear and binary search, plus selection and insertion sort. Efficiency comparisons appear every year.

Linear Search

Check each element one by one. Works on any array. O(n) time.

public static int linearSearch(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i;    // found at index i
        }
    }
    return -1;           // not found
}

Binary Search

Requires a sorted array. Eliminates half the remaining elements each step. O(log n) time.

public static int binarySearch(int[] arr, int target) {
    int low = 0, high = arr.length - 1;
    while (low <= high) {
        int mid = (low + high) / 2;
        if (arr[mid] == target) {
            return mid;
        }
        else if (arr[mid] < target) {
            low = mid + 1;
        }
        else {
            high = mid - 1;
        }
    }
    return -1;
}
⚠ Binary Search Requires Sorted Data: Using binary search on an unsorted array gives unpredictable, incorrect results. The AP exam tests whether you know this precondition.

Algorithm Comparison

Algorithm Requirement Time Best for
Linear Search None O(n) Small or unsorted data
Binary Search Sorted array O(log n) Large sorted data
Selection Sort None O(n²) Small arrays
Insertion Sort None O(n²) Nearly sorted data

📝 Practice Question 1

Binary search is performed on the sorted array {3, 7, 12, 19, 25, 31, 42} looking for 19. In what order are the middle elements checked?

📝 Practice Question 2

Which of the following statements about searching algorithms is correct?

I. Linear search can be used on unsorted arrays.
II. Binary search is always faster than linear search.
III. Binary search requires the array to be sorted.

✅ Exam Tip: Binary search questions ask you to trace the low/high/mid values step by step. Practice this: write out low, high, mid after each iteration. The exam often asks how many comparisons are needed — binary search on 1000 elements needs at most 10 (log&sub2;1024 = 10).
Back to blog

Leave a comment

Please note, comments need to be approved before they are published.