Reverse a Singly Linked List Iterative in DSA C - Build from Scratch

Reverse a Singly Linked List Iterative

📖 Scenario: You are working on a simple program that manages a list of tasks. Each task is stored in a singly linked list. Sometimes, you want to see the tasks in reverse order. To do this, you will reverse the linked list using an iterative method.

🎯 Goal: Build a C program that creates a singly linked list with exact tasks, then reverses the list iteratively, and finally prints the reversed list.

📋 What You'll Learn

Create a singly linked list with nodes containing integer values 1, 2, 3, 4, 5 in that order

Add a pointer variable to help reverse the list

Implement an iterative function to reverse the singly linked list

Print the reversed linked list values separated by ' -> ' and ending with ' -> NULL'

💡 Why This Matters

🌍 Real World

Reversing linked lists is useful in many applications like undo features, navigation history, and data processing pipelines.

💼 Career

Understanding linked list reversal is a common interview question and helps build strong problem-solving skills in data structures.

1

Create the singly linked list

Define a struct called Node with an int data and a Node* called next. Then create five nodes with data values 1, 2, 3, 4, 5 linked in order. Finally, create a pointer called head that points to the first node.

DSA C

// Define struct Node and create linked list nodes with values 1 to 5
// Link nodes and set head pointer
// Your code here

Hint

Remember to link each node's next pointer to the following node, and set the last node's next to NULL.

2

Add pointers for reversing the list

Inside main, declare three pointers: prev, current, and next. Initialize prev to NULL and current to head. These will help reverse the list iteratively.

DSA C

#include 
#include 

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

int main() {
    Node* node1 = (Node*)malloc(sizeof(Node));
    Node* node2 = (Node*)malloc(sizeof(Node));
    Node* node3 = (Node*)malloc(sizeof(Node));
    Node* node4 = (Node*)malloc(sizeof(Node));
    Node* node5 = (Node*)malloc(sizeof(Node));

    node1->data = 1;
    node2->data = 2;
    node3->data = 3;
    node4->data = 4;
    node5->data = 5;

    node1->next = node2;
    node2->next = node3;
    node3->next = node4;
    node4->next = node5;
    node5->next = NULL;

    Node* head = node1;

    // Declare pointers prev, current, next
    // Initialize prev to NULL and current to head
    // Your code here

    return 0;
}

Hint

These pointers will help you keep track of nodes while reversing the links.

3

Iteratively reverse the linked list

Write a while loop that runs while current is not NULL. Inside the loop, do these steps in order: set next to current->next, set current->next to prev, move prev to current, and move current to next. After the loop, set head to prev.

DSA C

#include 
#include 

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

int main() {
    Node* node1 = (Node*)malloc(sizeof(Node));
    Node* node2 = (Node*)malloc(sizeof(Node));
    Node* node3 = (Node*)malloc(sizeof(Node));
    Node* node4 = (Node*)malloc(sizeof(Node));
    Node* node5 = (Node*)malloc(sizeof(Node));

    node1->data = 1;
    node2->data = 2;
    node3->data = 3;
    node4->data = 4;
    node5->data = 5;

    node1->next = node2;
    node2->next = node3;
    node3->next = node4;
    node4->next = node5;
    node5->next = NULL;

    Node* head = node1;

    Node* prev = NULL;
    Node* current = head;
    Node* next = NULL;

    // Use a while loop to reverse the list iteratively
    // Your code here

    return 0;
}

Hint

Change the direction of each node's next pointer to point to the previous node.

4

Print the reversed linked list

Use a Node* pointer called temp to traverse the reversed list starting from head. Inside a while loop, print the data of each node followed by " -> ". After the loop, print "NULL" and a newline.

DSA C

#include 
#include 

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

int main() {
    Node* node1 = (Node*)malloc(sizeof(Node));
    Node* node2 = (Node*)malloc(sizeof(Node));
    Node* node3 = (Node*)malloc(sizeof(Node));
    Node* node4 = (Node*)malloc(sizeof(Node));
    Node* node5 = (Node*)malloc(sizeof(Node));

    node1->data = 1;
    node2->data = 2;
    node3->data = 3;
    node4->data = 4;
    node5->data = 5;

    node1->next = node2;
    node2->next = node3;
    node3->next = node4;
    node4->next = node5;
    node5->next = NULL;

    Node* head = node1;

    Node* prev = NULL;
    Node* current = head;
    Node* next = NULL;

    while (current != NULL) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    head = prev;

    // Print the reversed list
    // Your code here

    return 0;
}

Hint

Traverse the list from head and print each node's data followed by ' -> '. End with 'NULL'.