Imagine you're in a vast building with no directory and no room numbers visible from hallways. Instead, each room has a sign inside pointing to the next room you should visit. To find what you're looking for, you must start at the entrance, enter the first room, read its sign, move to the next room, and repeat until you reach your destination—or until a sign says "no more rooms."

This is precisely how traversal works in linked structures. You cannot jump directly to the 50th node because there's no global index telling you where it is. You must start at the head (the entrance), follow each node's pointer to the next, and walk the chain one step at a time.

Traversal is the most fundamental operation on linked structures. Every other operation—searching, inserting, deleting, reversing—requires traversal. Master traversal, and you've built the foundation for mastering linked lists entirely.

Traversal is the process of visiting every node in a data structure, one at a time, in a systematic way. For linked lists, this means:

1. Starting at the head node
2. Processing the current node (reading data, modifying it, etc.)
3. Moving to the next node via the pointer
4. Repeating until there are no more nodes

The Fundamental Traversal Loop:

In pseudocode, traversal looks like this:

current = head
while current is not null:
    process(current)
    current = current.next

That's it. Those four lines capture the essence of linked list traversal. Let's break down what's happening:

1. current = head: We initialize a pointer variable to track our position. We start at the head because that's our only entry point to the list.

2. while current is not null: We continue as long as we have a valid node. When current becomes null, we've passed the end of the list.

3. process(current): This is where we do whatever we came to do—print the value, search for a match, sum elements, whatever.

4. current = current.next: We advance to the next node by following the current node's pointer. This is the "step forward" in our walk through the list.

Let's trace through traversal step by step with a concrete example.

Given: A linked list: 10 → 20 → 30 → null

Memory Layout (hypothetical addresses):

+----------+----------+----------+
| Node A   | Node B   | Node C   |
| addr:100 | addr:200 | addr:300 |
+----------+----------+----------+
| data: 10 | data: 20 | data: 30 |
| next:200 | next:300 | next:null|
+----------+----------+----------+

head = 100 (points to Node A)

Traversal Execution:

Key Observations:

1. current is a copy: When we write current = head, we're copying the address stored in head (which is 100) into current. Both variables now hold the same address, but they're separate variables. Changing current later doesn't affect head.

2. The list itself is unchanged: Traversal is a read-only operation (unless we deliberately modify nodes during processing). After traversal, the list is exactly as it was before. We've just "walked" through it.

3. current advances by reassignment: Each current = current.next makes current point to a different node. We're not moving data—we're moving our view.

4. null is the natural terminator: The loop ends because Node C's next is null. We didn't need a separate "length" variable or end marker—null itself signals the end.

Let's see traversal implemented in multiple languages to reinforce that the pattern is universal.

Python:

def traverse(head):
    current = head
    while current is not None:
        print(current.value)  # Process the node
        current = current.next

Java:

void traverse(ListNode head) {
    ListNode current = head;
    while (current != null) {
        System.out.println(current.val);  // Process the node
        current = current.next;
    }
}

C++:

void traverse(ListNode* head) {
    ListNode* current = head;
    while (current != nullptr) {
        cout << current->data << endl;  // Process the node
        current = current->next;
    }
}

JavaScript:

function traverse(head) {
    let current = head;
    while (current !== null) {
        console.log(current.val);  // Process the node
        current = current.next;
    }
}

Notice the Pattern:

Despite the syntactic differences, every version follows the identical logic:

1. Initialize a current pointer to head
2. Loop while current is not null
3. Process the current node
4. Advance current to the next node

Once you internalize this pattern, you can traverse a linked list in any language.

Traversal is rarely performed just to "visit" nodes—we usually want to accomplish something. Here are the most common operations performed during traversal:

1. Finding the Length:

def length(head):
    count = 0
    current = head
    while current is not None:
        count += 1
        current = current.next
    return count

We increment a counter at each node. The counter's final value is the list length.

2. Searching for a Value:

def contains(head, target):
    current = head
    while current is not None:
        if current.value == target:
            return True
        current = current.next
    return False

We check each node's value. If we find the target, return early. If we exhaust the list, the target isn't there.

3. Summing All Values:

def sum_list(head):
    total = 0
    current = head
    while current is not None:
        total += current.value
        current = current.next
    return total

We accumulate values as we traverse.

4. Finding the Tail:

def find_tail(head):
    if head is None:
        return None
    current = head
    while current.next is not None:  # Note: checking current.next, not current
        current = current.next
    return current

We traverse until we find the node whose next is null—that's the tail.

5. Collecting Values into a List:

def to_list(head):
    result = []
    current = head
    while current is not None:
        result.append(current.value)
        current = current.next
    return result

We build an array/list of all values during traversal.

Robust traversal code must handle edge cases gracefully. The most common edge cases are:

1. Empty List (head is null):

If head is null, the list has zero nodes. Our standard loop handles this correctly:

current = head  # current is null
while current is not None:  # condition is False immediately
    ...  # never executed

The loop body never runs, which is correct—there's nothing to traverse.

2. Single-Element List:

If the list has exactly one node, head.next is null:

current = head  # current points to the one node
while current is not None:  # True (current is not null)
    process(current)  # process the one node
    current = current.next  # current becomes null
# Loop exits

This works correctly—we process the single node, then exit.

3. Very Long Lists:

Without special handling, very long lists just take more time. But for extraordinarily long lists (millions of nodes), you should:

• Ensure no recursion (avoid stack overflow)
• Consider whether the O(n) traversal is acceptable
• Verify memory is managed correctly

Sometimes you need to know not just the current node, but its position in the list (e.g., "this is the 5th node"). Since linked lists have no built-in indices, you must track position yourself:

Index-Tracked Traversal:

def print_with_index(head):
    index = 0
    current = head
    while current is not None:
        print(f"Index {index}: {current.value}")
        index += 1
        current = current.next

Finding the Node at a Specific Index:

def get_node_at(head, target_index):
    index = 0
    current = head
    while current is not None:
        if index == target_index:
            return current
        index += 1
        current = current.next
    return None  # Index out of bounds

This is O(n) in the worst case—you might need to traverse the entire list to reach index n-1.

Comparison with Arrays:

Many linked list operations require knowing the previous node, not just the current one. For example:

• Deletion: To remove a node, you need to update the previous node's next pointer
• Insertion before: To insert before a node, you need to modify the previous node's next
• Conditional operations: Sometimes the decision depends on comparing adjacent nodes

The Pattern: Two Pointers—prev and current:

def traverse_with_prev(head):
    prev = None
    current = head
    while current is not None:
        # Now we have access to both prev and current
        print(f"prev: {prev.value if prev else None}, current: {current.value}")
        prev = current
        current = current.next

Execution Trace:

List: 10 → 20 → 30 → null

Iteration 1: prev=None, current=10
Iteration 2: prev=10,   current=20
Iteration 3: prev=20,   current=30
Loop ends:  prev=30,   current=null

Example: Delete a Node with a Given Value:

def delete_value(head, target):
    # Handle deletion of head
    if head is not None and head.value == target:
        return head.next  # New head is the second node
    
    prev = None
    current = head
    while current is not None:
        if current.value == target:
            prev.next = current.next  # Skip over current
            return head
        prev = current
        current = current.next
    
    return head  # Target not found, list unchanged

Without prev, we couldn't update the predecessor's next pointer to skip the deleted node.

We've focused on iterative traversal (using loops), but traversal can also be done recursively. Let's compare the two approaches.

Iterative Traversal:

def print_list_iterative(head):
    current = head
    while current is not None:
        print(current.value)
        current = current.next

Recursive Traversal:

def print_list_recursive(node):
    if node is None:
        return
    print(node.value)
    print_list_recursive(node.next)

Both achieve the same result—printing all values in order.

How Recursion Works Here:

1. Base case: If the node is null, do nothing (return).
2. Recursive case: Process the current node, then recursively process the rest of the list.

The recursive call stack implicitly tracks our position in the list.

Recursive Reverse-Order Traversal:

One advantage of recursion is that we can easily process nodes in reverse order:

def print_reverse(node):
    if node is None:
        return
    print_reverse(node.next)  # Process rest first
    print(node.value)         # Then process current

Output for list 10 → 20 → 30: prints 30, 20, 10.

With iteration, achieving reverse order requires either reversing the list first or using an explicit stack.

Let's consolidate the traversal patterns we've covered into a reference guide:

Pattern 1: Simple Traversal (Process All Nodes)

current = head
while current is not None:
    process(current)
    current = current.next

Pattern 2: Search (Early Exit)

current = head
while current is not None:
    if condition(current):
        return current
    current = current.next
return None  # Not found

Pattern 3: Find Tail (Stop Before Null)

if head is None:
    return None
current = head
while current.next is not None:
    current = current.next
return current  # This is the tail

Pattern 4: Track Previous Node

prev = None
current = head
while current is not None:
    # Access both prev and current
    prev = current
    current = current.next

Pattern 5: Track Position (Index)

index = 0
current = head
while current is not None:
    if index == target:
        return current
    index += 1
    current = current.next

Pattern 6: Collect Results

results = []
current = head
while current is not None:
    results.append(transform(current))
    current = current.next
return results

Let's consolidate everything we've learned about following links to traverse:

What's Next:

Every traversal must end somewhere, and in linked lists, that "somewhere" is null. The next page explores null in depth: what it means, why it's essential, how to handle it safely, and the bugs that arise from misunderstanding it. Null is simple in concept but a source of countless errors in practice.