Loops

Why Do We Need Loops?

If you want to print "Hello" five times, you could simply write the print command five times. But what if you need to process a database of 10,000 users? Or search through a million pixels in an image to find a specific color? Writing linear code for massive or dynamic datasets is impossible.

We need a way to tell the computer: "Take this small block of instructions and repeat it until a specific condition is met." This is where loops come in. They are the engine of automation, allowing a few lines of code to process millions of data points in milliseconds.

What Is a Loop?

In Java that condition must be a Boolean. C, C++, Python and JavaScript apply their own truthiness rules to it, which Conditions covers.

How Loops Work

Almost every loop relies on four fundamental pillars to operate safely:

• Initialization: Setting up a starting variable (the counter or tracker) before the loop begins.
• Condition: The test evaluated before every single cycle. If it holds, the loop runs. If it does not, the loop stops.
• Loop Body: The actual block of code (instructions) being repeated.
• Iteration / Update: The mechanism that modifies the initialization variable (usually adding or subtracting 1) so that the condition will eventually become false.

The while Loop

The while loop is the simplest loop. It evaluates the condition before executing the body.

It is best used when there is no counter driving the loop, and it ends because something in the body changed: reading a file until it runs out, or waiting for a user to enter a valid password.

int count = 1;          // 1. Initializationwhile (count <= 3) {    // 2. Condition    System.out.println("Loop " + count);  // 3. Body    count++;            // 4. Update}

Note the fourth pass. The condition is checked one extra time, the time it fails, and that check is what ends the loop. A loop that prints three lines evaluates its condition four times.

The do–while Loop

The do-while loop is an inverted while loop. It executes the body first, and checks the condition after.

This guarantees that the loop body will always run at least once, even if the condition is false from the very beginning. It is frequently used for user menus ("Do this action, while the user hasn't pressed Quit").

// showMenu(), readChoice() and handle() are functions you would write yourselfint choice;do {    showMenu();              // drawn before anything is checked    choice = readChoice();    handle(choice);} while (choice != QUIT);

The menu has to appear once before there is any choice to test, which is the shape do-while exists for.

The for Loop

The for loop consolidates initialization, condition, and update into a single, clean line.

It is best when the loop has a clear starting point, boundary, and update, especially when iterating through a range or a collection. You do not have to know the count in advance: for (int i = 0; i < n; i++) is a for loop whose length is only known when it runs.

//  Init     ; Condition ; Updatefor (int i = 1; i <= 3; i++) {    System.out.println("Loop " + i);}

The for-each Loop

When you only need each value and do not need its index, a for-each loop is usually cleaner.

int[] numbers = {10, 20, 30}; for (int number : numbers) {    System.out.println(number);}

Use a traditional for loop when you need the index. Use a for-each loop when you only need the elements.

Choosing Between for, while, and do–while

• Use for when the loop has a counter or an iteration variable. The header keeps initialization, condition and update in one place, where they are hard to forget.
• Use while when there is no counter, and the loop ends because something in the body changed: a flag flipped, a file ran out, input became valid.
• Use do-while when the body must run once before there is anything to test.

What if the exit point is in the middle of the body? Then neither a counter nor a leading test fits, and the usual answer is while (true) with a break at the point where the work is done. A menu loop is the standard example, and it is how a do-while is written in a language that does not have one.

Loop Boundaries

Managing the start and end of a loop is where most beginners struggle.

Think in ranges. Rather than memorising < against <=, read the header and write down the values the counter actually takes.

for (int i = 0; i < n; i++)    ->  i = 0, 1, 2, ..., n - 1    (n times)for (int i = 1; i <= n; i++)   ->  i = 1, 2, 3, ..., n        (n times)

Both run n times. The bound moved because the starting point moved, which is the actual rule underneath the two symbols.

The same loop written both ways, with n fixed at 5:

for (int i = 0; i < 5; i++)    ->  0 -> 1 -> 2 -> 3 -> 4 -> stopfor (int i = 0; i <= 5; i++)   ->  0 -> 1 -> 2 -> 3 -> 4 -> 5 -> stop

The difference between < and <= is only one value, but that one value is responsible for countless off-by-one bugs.

• Inclusive vs Exclusive: < 10 is exclusive (stops at 9). <= 10 is inclusive (stops at 10).
• Off-by-one errors (OBOB): Since arrays start at index 0, looping to <= array.length will cause an out-of-bounds crash. You must use < array.length.
• Backward iteration: To read data in reverse, initialize at the end, set the condition to >= 0, and decrement (i--): for (int i = array.length - 1; i >= 0; i--)

The fencepost problem. A related bug that is not quite an off-by-one. Joining five values with a comma needs five values and only four separators, so a loop that writes a separator on every pass leaves one dangling at the end:

1, 2, 3, 4, 5,     <- a separator after every item1, 2, 3, 4, 5      <- what you wanted

The usual fixes are to write the separator before every item except the first, or to write the first item outside the loop. Fence posts and fence panels: five posts hold four panels.

Loop Control Statements

break and continue get a full treatment in Control Flow, which comes next. Here is what you need in order to read the loops in this chapter:

break leaves the loop entirely:

for (int i = 1; i <= 10; i++) {    if (i == 5) break;    System.out.println(i);}

1234

continue skips the rest of the current pass and goes on to the next one:

for (int i = 1; i <= 5; i++) {    if (i == 3) continue;    System.out.println(i);}

1245

break ends the loop. continue ends only the current iteration.

In a C-style for loop, continue skips the rest of the body and then executes the loop's update expression before checking the condition again. In a Python for loop, continue simply moves on to the next item, because there is no update expression to skip. A Python while loop has the same hazard as Java's, since there the update is just a statement in the body.

Nested Loops

A loop placed inside another loop is a nested loop.

Think of a digital clock: the minute hand (outer loop) ticks once, and the second hand (inner loop) must tick 60 times before the minute hand ticks again. For every single iteration of the outer loop, the inner loop must complete its entire cycle.

for (int out = 1; out <= 3; out++) {    for (int in = 1; in <= 2; in++) {        System.out.println("Out: " + out + ", In: " + in);    }}// Runs 3 * 2 = 6 total times.

Out: 1, In: 1Out: 1, In: 2Out: 2, In: 1Out: 2, In: 2Out: 3, In: 1Out: 3, In: 2

Read the left column: it changes slowly. The right column resets to 1 every time the outer counter moves. The inner loop does not continue from where it left off, it starts over completely, and that restart is why the counts multiply instead of add.

Loop Conditions and Boolean Logic

Loop conditions are not restricted to simple comparisons. You can use logical operators (&&, ||) to create multi-faceted stopping points.

The flag pattern. A boolean that records whether something happened, so the loop can stop early and the code after it can tell what occurred:

boolean targetFound = false;int index = 0; while (index < array.length && !targetFound) {    if (array[index] == target) {        targetFound = true;    }    index++;}

The order of the two conditions matters, for the same reason it did in Conditions: index < array.length must be checked first, because once it fails there is no valid element to read. && never evaluates its right side after the left side fails.

Compare that with break: the same search written as a for loop with if (...) break; needs no flag at all. The flag earns its place when the code after the loop needs to know whether the search succeeded.

Counters, Accumulators and Traversal

Loops are frequently used to tally data.

• Counter: Tracks how many times something happens (count++).
• Accumulator: Keeps a running total of values (sum += value).

int sum = 0;for (int i = 1; i <= 5; i++) {    sum += i; // Accumulating 1 + 2 + 3 + 4 + 5}

Loops are also the primary tool for reading data structures from start to finish.

• Arrays: Use a for loop utilizing the index, usually from 0 to length - 1.
• Strings: Strings behave like sequences of characters and are traversed the same way, whether you are checking for vowels, palindromes, or substrings. In C, and in C++ when you use char[], a string is literally an array of characters; Java wraps one in a String object and Python has no character type at all.
• Collections: Most modern languages offer a "for-each" loop to cleanly traverse lists and sets without managing an index variable: for (String name : nameList).

Infinite Loops

An infinite loop occurs when the loop's condition never evaluates to false.

• How they happen: Forgetting the update statement (i++), creating a logically impossible condition (while (i > 0) when i is constantly increasing), or misusing continue in a while loop.
• How to prevent them: Always double-check that your update statement moves the initialization variable closer to the termination condition.

The simplest one:

int i = 0; while (i < 5) {    System.out.println(i);}

What is missing? i never changes, so i < 5 stays true forever and the loop prints 0 until you kill it. One line fixes it:

while (i < 5) {    System.out.println(i);    i++;}

The continue case is the least obvious of the three and the most worth seeing:

int i = 0;while (i < 10) {    if (i == 5) continue;   // skips i++, so i stays 5 forever    System.out.println(i);    i++;}

continue jumps straight to the condition test, skipping everything below it, including the update. In a for loop this is safe, because the update lives in the loop header and always runs. In a while loop the update is just another statement in the body, and continue skips it. This is the strongest practical argument for preferring for when you have a counter.

Loop Invariants: Your First Look

You do not need to master loop invariants yet. The important idea is that we can keep track of something that stays true throughout the loop. Later, this becomes a powerful tool for proving algorithms correct.

A loop invariant is a property that is true before the loop starts, stays true through every iteration, and is therefore still true after the loop finishes.

The simplest possible one:

int sum = 0;for (int i = 0; i < n; i++) {    sum += arr[i];}

The invariant is: after k iterations, sum holds the total of the first k elements.

It has three parts, and they have names you will meet again:

• Initialization: it is true at the start, when k is zero and sum is zero.
• Maintenance: each iteration adds exactly the next element, so if it was true before the pass it is true after it.
• Termination: when the loop ends k is n, which is the same as saying sum holds the total of the whole array: the thing you wanted, proved rather than assumed.

That is the whole technique, and it is how sorting and binary search are shown to be correct rather than merely tested.

Time Complexity of Loops

Before you can reason about cost, you have to know how many times a loop runs.

• for (int i = 0; i < n; i++) runs exactly n times.
• for (int i = 0; i < n; i += 2) runs about n/2 times, exactly ⌈n/2⌉, since the last step may land short of the bound.

In Data Structures and Algorithms, we evaluate code performance using Big-O notation, which directly measures loop behavior as the input size (n) grows.

What follows is the pattern-recognition half of it: enough to look at a loop and name its shape. The formal treatment - why the smaller terms are dropped, how sequential loops differ from nested ones, what the classes cost at a million elements - is Big O and Time Complexity, which come later in Foundations.

• Constant Loops O(1): for (int i = 0; i < 10; i++) (Always runs 10 times, regardless of n).
• Linear Loops O(n): for (int i = 0; i < n; i++) (Runs directly in proportion to n).
• Nested Loops O(n²): An O(n) loop inside an O(n) loop. If n = 10, it runs 100 times. The cost grows fast: doubling n quadruples the work.
• Dependent Loops O(n²): for (int i = 0; i < n; i++) { for (int j = i; j < n; j++) }. The inner loop shrinks as the outer loop grows, forming a triangle pattern. The passes add up to n + (n-1) + (n-2) + ... + 1, which is n(n+1)/2, and that is still O(n²).
• Logarithmic Loops O(log n): for (int i = 1; i < n; i *= 2). The loop variable doubles every iteration. Doubling reaches n in about log₂ n steps, so a million elements take roughly twenty passes.

Loops in DSA and Problem Solving

Loops are the operational chassis for almost every algorithm. A handful of shapes account for most of them:

Traversal           visit every elementSearching           stop when the target is foundAccumulation        build a single result from many valuesFrequency counting  tally how often each value appearsNested traversal    compare or combine every pairTwo pointers        move two indices based on conditionsSliding window      maintain a moving range

The algorithms themselves come later. What matters now is that each one is a loop with a particular update rule.

Binary Search uses a while loop that halves the search space every iteration. The Sliding Window technique uses a for loop to drag a frame across an array. Two Pointers use a while loop (left < right) to converge on a solution from opposite ends of a dataset.

Loops Across Languages

While the logic remains the same, syntax varies:

• Java / C++: Use the standard three-part for loop (for (int i=0; i<10; i++)).
• Python: Does not use the three-part C-style loop. It iterates over ranges or collections: for i in range(10): or while count < 5:.
• JavaScript: Supports traditional for loops, but heavily relies on array methods like .forEach() or the for...of syntax to read data directly.
• do-while: Java, C++ and JavaScript have it. Python does not; the idiom there is while True: with a break at the bottom.

Common Mistakes and Edge Cases

int sum = 0;int i; for (i = 0; i < 10; i++);   // the ; IS the body: ten empty passes sum += i; System.out.println(sum);

Quick Check

for (int i = 0; i < 5; i++) {    System.out.print(i + " ");}

int x = 1; while (x < 10) {    System.out.print(x + " ");    x *= 2;}

for (int i = 1; i <= 5; i++) {    if (i == 3) continue;    System.out.print(i + " ");}

for (int i = 1; i <= 3; i++) {    for (int j = 1; j <= 2; j++) {        System.out.println(i + "," + j);    }}

for (int i = 1; i <= 3; i++) {    System.out.print(i + ", ");}

Quick Recap

• Loops automate repetitive work, running until a stopping point is reached.
• Every safe loop requires initialization, a condition, an update, and a body.
• Use for when the loop has a counter, while when it ends because something in the body changed, and do-while when the body must run once first.
• A for-each loop visits every element without an index: use it when you do not need the position.
• break ends the loop; continue ends only the current pass.
• Boundaries are about ranges, not symbols: work out which values the counter actually takes.
• Fencepost: n items need n - 1 separators.
• Nested loops multiply the total number of iterations.
• Counters track occurrences; accumulators track running totals.
• An infinite loop is a condition that never turns false, usually a missing or misdirected update.
• Understanding how a loop scales as data grows (O(n), O(n²), O(log n)) is the foundation of algorithm analysis.
• A loop invariant holds before, during and after the loop, and it is how a loop is shown to be correct rather than merely tested.

Where This Leads

Operators     ↓Conditions     ↓Loops     ↓Control Flow     ↓Functions

At this point, you can calculate data, make complex decisions, and repeat those actions millions of times. But a loop that always runs to completion is wasteful: once you have found what you were searching for, you want out.

That is what Control Flow Statements are for: break, continue and return, the three ways to override a loop mid-flight. After that come Functions, which wrap all of this into something reusable.