Traversal (Displaying Nodes)

In a singly linked list (SLL), traversal means visiting each node from head until next is NULL. Below: iterative traversal (loop) and recursive traversal to print node values. Time O(n); iterative space O(1), recursive space O(n) for the call stack.

1) Iterative traversal (C)

Use a pointer cur that starts at head and moves with cur = cur->next until cur == NULL.

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node *next;
};

/* Walk the list and print each data value */
void traverse_iterative(struct Node *head)
{
    struct Node *cur = head;
    while (cur != NULL) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");
}

int main(void)
{
    struct Node *n1 = malloc(sizeof(struct Node));
    struct Node *n2 = malloc(sizeof(struct Node));
    struct Node *n3 = malloc(sizeof(struct Node));
    if (!n1 || !n2 || !n3) return 1;

    n1->data = 10; n1->next = n2;
    n2->data = 20; n2->next = n3;
    n3->data = 30; n3->next = NULL;

    struct Node *head = n1;
    traverse_iterative(head);   /* output: 10 20 30 */

    free(n1); free(n2); free(n3);
    return 0;
}

Program output

Running the program prints the three values on one line, then a newline:

Step-by-step execution

Memory layout (example addresses)

Function call trace (iterative loop)

Key observations

Critical points

In short, the program prints the three data values 10, 20, and 30 on one line with spaces between them, then ends the line with a newline.

2) Recursive traversal — display SLL values (C)

Base case: empty list (p == NULL). Otherwise print current node, then recurse on p->next. This prints in forward order (same as the loop above).

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node *next;
};

void display_recursive(struct Node *p)
{
    if (p == NULL)
        return;
    printf("%d ", p->data);
    display_recursive(p->next);
}

int main(void)
{
    struct Node *n1 = malloc(sizeof(struct Node));
    struct Node *n2 = malloc(sizeof(struct Node));
    struct Node *n3 = malloc(sizeof(struct Node));
    if (!n1 || !n2 || !n3) return 1;

    n1->data = 10; n1->next = n2;
    n2->data = 20; n2->next = n3;
    n3->data = 30; n3->next = NULL;

    display_recursive(n1);   /* output: 10 20 30 */
    printf("\n");

    free(n1); free(n2); free(n3);
    return 0;
}

Program output

The recursive program prints the same line as the iterative version, then a newline from main:

Recursive function call stack

Complete call stack trace (with recursion depth)

Memory layout (same list as iterative example)

Visual call tree

Timing: when prints happen

Recursive vs iterative

Key observations (recursive)

Reverse-order display (without reversing the list) swaps the two lines inside display_recursive: recurse first, then printf—that is covered in the reverse-traversal topic.

3) FAQ: Is void valid when the function uses return?

void display_recursive(struct Node *p)
{
    if (p == NULL)
        return;
    printf("%d ", p->data);
    display_recursive(p->next);
}

Answer: Yes, void is correct here. This is a typical recursive routine that walks the list and prints each node’s data without returning a value to the caller.

Why void fits

1. The function does work, not a computed result. It prints (a side effect). It does not need to return a value. Recursive calls drive the walk, not an accumulated return value.
2. The base case uses bare return; (not return expression). That simply exits the function and returns nothing—which matches a void return type:

   if (p == NULL)
       return;   /* exit; no value */
   

If you used a non-void type (e.g. int)

You could write something like this, but it is awkward and misleading for “print only”:

int display_recursive(struct Node *p)  /* misleading for this job */
{
    if (p == NULL)
        return 0;
    printf("%d ", p->data);
    return display_recursive(p->next);
}

• The return value is not needed for printing.
• Callers may wrongly assume they should use the returned int.
• It adds complexity without benefit for this pattern.