Loops

Overview — iteration & why loops

Without loops you would copy-paste the same statements dozens of times. Loops let you repeat work with a changing counter, until a condition fails, or until the user says stop.

• Iteration — one pass through the loop body
• Condition — expression tested to decide whether to keep looping (non-zero = true)
• Control variable — often a counter like i that updates each pass
• Infinite loop — condition never becomes false (sometimes intentional with break)

while loop

A while loop is entry-controlled: it checks the condition first. If the condition is false at the start, the body never runs.

Syntax:

while (condition) {
    /* statements repeated while condition is true */
}

Example — print 1 to 5:

int i = 1;
while (i <= 5) {
    printf("%d ", i);
    i++;
}

do-while loop

A do-while loop is exit-controlled: the body runs first, then the condition is checked. The body always executes at least once.

Syntax:

do {
    /* statements — run at least once */
} while (condition);

Example — menu-style repeat:

int choice;
do {
    printf("1.Hello  2.Exit: ");
    scanf("%d", &choice);
} while (choice != 2);

for loop

A for loop packs init, condition, and update in one header. It is also entry-controlled — ideal when the number of iterations is known or easy to express with a counter.

Syntax:

for (init; condition; update) {
    /* loop body */
}

Example — print 1 to 5:

int i;
for (i = 1; i <= 5; i++)
    printf("%d ", i);

Comparison — while vs do-while vs for

Nested loops — intro

A nested loop places one loop inside another. The outer loop often controls rows; the inner loop controls columns (or symbols on that row).

Example — 3×4 rectangle of stars:

int row, col;
for (row = 1; row <= 3; row++) {
    for (col = 1; col <= 4; col++)
        printf("*");
    printf("\n");
}

break and continue — basics

break leaves the innermost loop immediately. continue skips the rest of the current iteration and starts the next one.

break example:

for (int i = 1; i <= 10; i++) {
    if (i == 5)
        break;           /* stop loop when i is 5 */
    printf("%d ", i);
}
/* prints: 1 2 3 4 */

continue example:

for (int i = 1; i <= 5; i++) {
    if (i == 3)
        continue;        /* skip printing 3 */
    printf("%d ", i);
}
/* prints: 1 2 4 5 */

Entry-controlled vs exit-controlled loops

• Entry-controlled — while, for: test first; body may run zero times
• Exit-controlled — do-while: body first; then test; body runs ≥ 1 time
• Choose entry-controlled when “do nothing if already done” is correct
• Choose exit-controlled when the first pass must happen (show menu, read then validate)

for loop parts — init; condition; update

Each header slot is optional. Empty condition means “always true” (infinite until break).

• init — runs once before the loop (e.g. i = 0)
• condition — checked before each iteration; empty ⇒ forever
• update — runs after each body (e.g. i++), including after continue
• Empty expressions: for (; i < n; ) or for (;;) are legal

int i = 0;
for (; i < 3; ) {          /* init done outside; update in body */
    printf("%d ", i);
    i++;
}

for (;;) {                     /* intentional infinite loop */
    /* ... break when done ... */
    break;
}

Nested loops — O(n²) intuition & shadowing

If the outer loop runs n times and the inner loop runs n times each, the body runs about n × n times — often described as O(n²) time. Triple nesting is roughly O(n³). That is why nested loops on large n can feel slow.

• Prefer distinct names: row / col instead of two is
• C99 nested for (int i = ...) inside another i shadows the outer variable
• Reusing one i for both loops without care can break the outer counter

Pattern building — rows / cols thinking

Almost every star or number pattern follows: outer = rows, inner = what to print on that row (stars, digits, or spaces then stars).

1) Right triangle of stars (n = 4):

/* Row i prints i stars */
for (int row = 1; row <= n; row++) {
    for (int col = 1; col <= row; col++)
        printf("*");
    printf("\n");
}
/* *   **   ***   **** */

2) Number triangle:

for (int row = 1; row <= n; row++) {
    for (int col = 1; col <= row; col++)
        printf("%d ", col);
    printf("\n");
}
/* 1 / 1 2 / 1 2 3 / ... */

3) Inverted star triangle:

for (int row = n; row >= 1; row--) {
    for (int col = 1; col <= row; col++)
        printf("*");
    printf("\n");
}

break vs continue vs return

Infinite loops — intentional stop

Infinite loops are useful for interactive menus or servers — but only if you plan an exit:

• while (1) { … if (done) break; }
• for (;;) { … if (quit) return 0; }
• Accidental infinity: forgotten i++, wrong condition, or continue skipping the update in while

while (1) {
    printf("Enter 0 to stop: ");
    scanf("%d", &x);
    if (x == 0)
        break;              /* intentional exit */
}

Optional flowchart — while vs do-while

How the two loops decide whether the body runs: