What Is an Algorithm?

An algorithm is a finite, ordered set of instructions that accomplishes a specific task. The word "finite" matters — every algorithm must eventually terminate. An infinite loop is not a valid algorithm because it never reaches a result. Algorithms are not code-specific: the same algorithm can be expressed as pseudocode, a flowchart, natural language, or Java source code. The AP exam tests your ability to recognize algorithm structure regardless of the representation used.

Topic 2.1 is the only topic in Unit 2 with no Java syntax requirement. The College Board assesses it using Skill 1.A — determining an appropriate program design — applied to everyday-language or diagram descriptions. Every question will ask you to identify which building blocks (sequencing, selection, repetition) are present, or to determine how order changes the outcome.

The Three Building Blocks

Understanding these three building blocks is foundational to everything in AP CSA. Units 2 through 4 are entirely about implementing them in Java. Topic 2.1 asks you to recognize them in plain language before you write a single line of code.

Comparison table: the three building blocks

Recognizing Building Blocks in Everyday Algorithms

The AP exam presents algorithms in plain English or as flowcharts and asks you to identify which building blocks are present, how many of each, or how reordering them would change the result. The key skill is translating informal descriptions into structured thinking.

// SEQUENCING: runs top to bottom, once each
int balance = 500;
int amount = 200;

// SELECTION: branches based on a condition
if (amount <= balance) {
    balance -= amount;        // path when true
} else {
    System.out.println("Insufficient funds");  // path when false
}

// REPETITION: repeats until condition is false
while (userWantsAnother) {
    amount = getUserInput();
    if (amount <= balance) {
        balance -= amount;
    }
}

Order Matters: EK 2.1.A.5

The order in which sequencing, selection, and repetition are combined determines the outcome of an algorithm. This is one of the most frequently tested ideas in Topic 2.1. Two algorithms using the exact same three building blocks can produce completely different results if the order changes.

Flowchart Reading: AP Exam Skill

The AP exam frequently presents algorithms as flowcharts. You need to recognize which shapes represent which building blocks. The rules are consistent and simple:

Combining Building Blocks: Real-World Scenarios

Most real algorithms use all three building blocks together. The AP exam tests whether you can correctly identify which is which, and whether you can determine what happens when pieces are added, removed, or reordered.

Real-World Connection

Every piece of software ever written is built from these three blocks. A GPS routes you using repetition (check location every second) and selection (if you have left the route, recalculate). A hospital monitoring system uses repetition (check vitals every 30 seconds) and selection (if heart rate exceeds threshold, alert staff). A spreadsheet formula uses sequencing (evaluate each cell in order) and selection (IF functions). Recognizing these patterns in descriptions of systems you already use every day is exactly the skill Topic 2.1 develops — and it transfers directly to reading and writing Java code in every remaining unit of this course.

Summary

• Three building blocks: sequencing, selection, and repetition. Every algorithm uses some combination of these.
• Sequencing = run in order, once each. Default program flow.
• Selection = branch based on a true/false condition. One path (or neither) runs.
• Repetition = loop until a desired outcome. The block runs zero or more times.
• Order matters (EK 2.1.A.5): swapping the position of building blocks can completely change algorithm behavior.
• Topic 2.1 is conceptual: recognize these patterns in plain language and flowcharts. No Java syntax required by the CED for this specific topic.
• Flowcharts: diamonds = selection, rectangles = sequencing/action, back-arrows = repetition.

The Three Building Blocks of Algorithms

Every algorithm — no matter how complex — is built from just three components. You already know one from Unit 1.

Selection in Everyday Life

Selection is everywhere. Your phone’s autocorrect uses selection: if the word is misspelled, suggest a correction. A streaming app uses selection: if the user is a subscriber, show the full catalog.

if (amountInserted >= itemPrice) {
    dispenseItem();
} else {
    returnMoney();
}

Repetition in Everyday Life

Repetition handles tasks that need to happen multiple times. A car wash repeats its scrubbing cycle for every car. An email app checks for new mail repeatedly on a timer.

while (moreItems) {
    scanNextItem();
    updateTotal();
}

Order Matters

The order in which sequencing, selection, and repetition appear changes the result of an algorithm. Consider two versions of checking a PIN: