Units 2 — Selections & Iteration

Algorithms with Selection and Repetition

Every algorithm is built from three control structures, combined in any order or nesting:

• Sequence — statements run one after another, top to bottom.
• Selection — a branch point where the program picks one path based on a condition (if).
• Repetition (iteration) — a block of code repeats while some condition holds (while, for).

Boolean Expressions

A Boolean expression is any expression that evaluates to exactly one of two values: true or false. They're built using relational operators (== != < > <= >=) and combined with logical operators (&& || !) — see 1.16 for the full table.

boolean isTeen = (age >= 13) && (age <= 19);
boolean failed  = grade < 60;
System.out.println(isTeen);   // prints "true" or "false" directly

A Boolean expression can be stored in a boolean variable, printed directly, or used immediately as the condition of an if or a loop.

if Statements

An if statement runs a block of code only when its Boolean condition is true. Pairing it with else gives a second path when the condition is false.

if (temperature > 90) {
    System.out.println("It's hot");
} else {
    System.out.println("It's not that hot");
}

• The condition must be inside parentheses and must be a Boolean expression.
• Curly braces group multiple statements into one block; without them, only the very next single statement belongs to the if.
• else is optional — an if with no else simply does nothing when the condition is false.

if (score >= 60)
    System.out.println("Pass");
    System.out.println("Recorded");

Nested if Statements

Nested ifs place an if inside another if (or its else), allowing multi-way branching. else if chains are the most common pattern.

if (grade >= 90) {
    System.out.println("A");
} else if (grade >= 80) {
    System.out.println("B");
} else if (grade >= 70) {
    System.out.println("C");
} else {
    System.out.println("F");
}

• In an else if chain, Java checks each condition top-to-bottom and stops at the first one that's true — order matters.
• A series of independent if statements (no else) all get checked, even after one is true — very different behavior from a chain.

Compound Boolean Expressions

Combining multiple conditions with &&, ||, and ! builds richer conditions than any single comparison can express.

boolean eligible = (age >= 16) && hasPermit && !hasViolation;

if (day == "Sat" || day == "Sun") {
    System.out.println("Weekend");
}

Recall from 1.16 that && and || short-circuit — this is especially useful for guarding against errors, like checking an index is in range before using it.

Comparing Boolean Expressions

Two Boolean expressions are logically equivalent if they produce the same true/false result for every possible input. De Morgan's Laws describe how negation distributes over && and ||:

// these two conditions are logically equivalent
if (!(x > 0 && y > 0)) { ... }
if (x <= 0 || y <= 0)   { ... }

To verify two expressions are equivalent, build a truth table — list every combination of the input variables and check the outputs match in every row.

while Loops

A while loop repeats a block of code as long as its condition remains true, checking the condition before each pass. It's ideal when you don't know in advance how many times you'll loop.

int count = 0;
while (count < 5) {
    System.out.println(count);
    count++;   // without this, the loop never ends
}

• The condition is checked before every iteration — if it's false immediately, the body never runs at all.
• Something inside the loop must eventually make the condition false, or you get an infinite loop.
• while is common for sentinel-controlled loops — e.g. keep reading input until the user types "quit."

int n = 10;
while (n > 0) {
    n -= 3;
}
System.out.println(n);

for Loops

A for loop packages initialization, condition, and update into one header — ideal when you know roughly how many times you'll loop (a definite loop).

for (int i = 0; i < 5; i++) {
    System.out.println(i);   // prints 0 1 2 3 4
}

Every for loop can be rewritten as a while loop, and vice versa — for is just more compact when a counter is involved.

int sum = 0;
for (int i = 1; i <= 4; i++) {
    sum += i;
}

Implementing Selection and Iteration Algorithms

Most algorithms combine loops with ifs using a small set of reusable patterns:

int[] scores = {72, 95, 60, 88};
int sum = 0, passingCount = 0, max = scores[0];

for (int s : scores) {
    sum += s;                      // accumulator
    if (s >= 70) passingCount++;  // counter
    if (s > max) max = s;         // max tracker
}

Implementing String Algorithms

Strings are iterated character-by-character using .length() and .charAt(i) inside a loop — the same accumulator patterns from 2.9 apply directly.

int vowels = 0;
String s = "education";
for (int i = 0; i < s.length(); i++) {
    char c = s.charAt(i);
    if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') {
        vowels++;
    }
}
// building a new string char by char
String reversed = "";
for (int i = s.length() - 1; i >= 0; i--) {
    reversed += s.charAt(i);
}

Nested Iteration

A loop placed inside another loop is nested iteration. For each single pass of the outer loop, the entire inner loop runs to completion.

for (int row = 1; row <= 3; row++) {
    for (int col = 1; col <= 3; col++) {
        System.out.print(row * col + " ");
    }
    System.out.println();   // new line after each row
}
// prints a 3x3 multiplication grid

The outer loop runs 3 times; for each of those, the inner loop runs 3 times — so the inner body executes 3 × 3 = 9 times total. This multiplying effect is the key idea behind nested loops.

Informal Run-Time Analysis

Run-time analysis asks: as the input size n grows, how does the number of operations grow? This is described informally with Big-O notation.

// O(n) — one pass through the array
for (int x : arr) { sum += x; }

// O(n^2) — inner loop re-scans for every outer element
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr.length; j++) {
        // n x n work
    }
}