Walking a List: The cur = head, while (cur != null) Idiom

Try This First

You have a three-element list: head -> [10] -> [20] -> [30] -> null. Starting with Node<Integer> cur = head;, you enter the loop and print cur.data, then write cur = cur.next;. How many times does the print statement run before the loop ends?

What You Need To Walk In With

• A linked list in this course stores a reference called head that points to the first node (or is null for an empty list).
• Each node holds a data field of type T and a next reference pointing to the following node (or null at the end of the chain).
• The traversal idiom initializes a local pointer cur to head and advances it one step per iteration until cur is null.
• On an empty list (head == null), the loop body never executes because the condition fails immediately.
• For a list of N elements the loop body executes exactly N times (source: Liang 10e Ch 24).

How It Works

The traversal idiom has three parts: initialize, test, and advance.

Node<T> cur = head;          // 1. Start at the first node (or null)
while (cur != null) {        // 2. Stop when there is no more node
    System.out.println(cur.data);
    cur = cur.next;          // 3. Move one step toward the end
}

A rough picture of what happens on a two-element list:

head
 |
[A | next] -> [B | next] -> null
  ^
  cur (iteration 1: prints A, then cur = cur.next)
              ^
              cur (iteration 2: prints B, then cur = cur.next => null)
                               ^
                               cur == null => loop exits

After the loop, cur is guaranteed to be null. The original head reference is untouched because cur is a local copy.

The for-loop form is equivalent and more compact, though Steiner’s published 211 labs use the while form:

for (Node<T> cur = head; cur != null; cur = cur.next) {
    System.out.println(cur.data);
}

Both forms visit every node in order and terminate cleanly on an empty list.

Worked Example: Predict, Then Check

Consider this list and code fragment:

// List contains: 5 -> 12 -> 7 -> null
Node<Integer> cur = head;
int count = 0;
while (cur != null) {
    if (cur.data > 8) count++;
    cur = cur.next;
}
System.out.println(count);

What does the program print?

A Common Mistake

It is tempting to write while (cur.next != null) instead of while (cur != null). That change skips the last node in the list because the condition becomes false one step too early (when cur points to the final node, cur.next is already null). Worse, on an empty list where head == null, the condition tries to evaluate null.next, which throws a NullPointerException immediately. The fix is always to test cur itself: while (cur != null). That condition handles both the empty-list case and ensures every node, including the last one, is processed. (Source: Liang 10e Ch 24)

Go Deeper (optional)

This traversal runs in O(N) time because each of the N nodes is visited exactly once. That cost appears in every method that needs to inspect all elements (searching, counting, building a string representation). If you later study the dummy-head variant, the loop body does not change; the only difference is that the loop starts at head.next rather than head. For now, the no-dummy-head form is the course standard, and every method special-cases an empty list by checking head == null before entering the traversal.

Check Yourself

Close the notes and answer each one from memory, then reveal it. Pulling an idea back from memory is one of the strongest ways to make it stick.