Reversing a Linked List

Iterative and recursive approaches to reverse a linked list.

Reversing by Changing Node Data & Using an Array :

  • Pass the pointer to head node and an array as parameters.

  • Using a while loop, copy the data from each node to the array until the pointer becomes NULL.

  • Set the pointer to head and decrement to index i by 1 to reach the last element of array.

  • Overwrite the data in each node using a while loop and keep decrementing the index i until pointer becomes NULL.

void reverse(struct node *ptr, int a[]) {
    // A variable to keep track of array index
    int i = 0;
    // Copy data from linked list to array
    while (ptr != NULL) {
        a[i] = ptr -> data;
        ptr = ptr -> next;
    // Set index to begin reverse procedure
    ptr = head;
    // Copy data from array to linked list in reverse
    while (ptr != NULL) {
        ptr -> data = a[i];
        ptr = ptr -> next;

Reversing using Sliding Pointers :

  • Take two additional pointers, prev and next, and initialise them with NULL.

  • Copy the next address of each node to the next pointer and then set the next address of node to the prev pointer.

  • Make current as next and prev as current in order to move forward.

  • Do this procedure until current becomes NULL.

  • Set the head node as prev pointer.

void reverse(struct node *ptr) {

    // Consider ptr to the pointer to current node
    struct node *prev = NULL;
    struct node *next = NULL;

    while (ptr != NULL) {
        // Store the address of next node
        next = ptr -> next;
        // Make the next of each node point to its previous
        ptr -> next = prev;
        // Move forward
        prev = ptr;
        ptr = next;
    // Setting the value of head node
    head = prev;   

Reversing by Recursion :

void reverse(struct node *prev, struct node *curr) {

    if (curr != NULL) {
        reverse(curr, curr -> next);
        curr -> next = prev;        
    } else {
        head = prev;


// Function call : reverse(NULL, head) 

Contributed by Nitin Ranganath

Last updated