Web Development

# Reverse a Linked List: Algorithm, Examples & Best Practices

Last Updated: 13th June, 2023

Arunav Goswami

Data Science Consultant at almaBetter

Whether you are a beginner or an experienced developer, this article serves as a valuable resource for mastering the technique of reversing a linked list.

## Introduction

A linked list is a technique to store a list of things, like a to-do list, where each item has a reference to the next item in the list. It's like a chain, where each link points to the next link. You can add or remove items easily by changing the links between them. In technical terms, A linked list is a data structure used for storing a sequence of elements. It consists of a sequence of nodes, each containing some data and a reference to the next node in the list.

Reversing a linked list means changing the order of the elements in the list so that the last element becomes the first, the second-to-last becomes the second, and so on. This is usually done by updating the references in each node to point to the previous node instead of the next one, effectively reversing the direction of the list.

### Understanding Reversal of Linked List with the Help of a Story

There was a little girl named Alice who enjoyed playing with her toy trains. She had an extensive track set up in her room that snaked around her bed, bookshelf, and beloved armchair. One day, she decided to arrange her trains on the track in a specific sequence: first, the red train, then the blue, the green, and finally, the yellow train.

Alice was content with her trains' arrangement, but her younger brother Bob entered her room and wanted to play with the trains as well. Unlike Alice, Bob was not very orderly, and he chose to play with the trains by haphazardly pushing them along the track. When he finished, the trains' order was completely different from Alice's initial setup.

Unhappy with the new arrangement, Alice resolved to reverse the order. She placed the yellow train at the front of the track, followed by the green, the blue, and lastly, the red train. The trains were now in the precise order she desired.

Similarly, we can reverse a linked list's order, much like Alice did with her trains. A linked list can be compared to a train track, where each train car represents a node in the list and contains a reference to the subsequent car. To reverse the list, we need to alter the next reference of each node to point to the preceding node instead of the following one. This is akin to positioning the last train car at the track's beginning, succeeded by the second-to-last car, and so forth.

### Situations where reversing a linked list might be useful:

1. Pagination: When implementing pagination on a website or application, a linked list can be used to represent the list of items being paginated. Reversing the linked list can make it easier to display the most recent items first.
2. Text editing: In a text editor, a linked list can be used to represent the characters in a document. Reversing the list can be useful for operations like searching for a word or sentence from the end of the document.
3. Routing tables: In computer networking, routing tables are used to determine the best path for data packets to travel between nodes on a network. Linked lists can be used to represent the routing table, and reversing the list can help to optimize the pathfinding algorithm.
4. Audio and video processing: In digital signal processing, linked lists can be used to represent the data stream of an audio or video file. Reversing the list can be useful for certain audio and video processing algorithms, such as reverse playback or real-time effects processing.

## Reversing a linked list iteratively

Iterative solutions use loops and conditionals to repeatedly execute a block of code until a condition is met. Iterative solutions are often more efficient in terms of memory usage and execution time since they don't require the overhead of function calls and maintaining a call stack.

Let's say we have the following linked list:

`Loading... `

Initially, we have three pointers:

`Loading... `

We start by reversing the first node in the list:

`Loading... `

We then move the prev, current, and next pointers to the next node:

`Loading... `

We repeat this process for each node in the list until we reach the end:

`Loading... `
`Loading... `

At this point, the list has been fully reversed. We update the head pointer to the last node, which is 4, and return it.

A complete code to reverse the linked list iteratively would be:

`Loading... `

Common challenges or errors that can arise:

1. Off-by-one errors: It's easy to make off-by-one errors when manipulating pointers in a linked list. This can result in the list being incorrectly reversed or even in an infinite loop.
2. Pointer reassignment: When reversing a linked list iteratively, it's important to keep track of the previous, current, and next pointers. If these pointers are not properly reassigned during the reversal process, it can result in the list being incorrectly reversed.
3. Null pointer exceptions: Null pointer exceptions can occur when trying to manipulate a null pointer in a linked list. This can happen if the pointers are not properly initialized or if the list is empty.
4. Memory leaks: Memory leaks can occur if the memory used by the nodes in the linked list is not properly deallocated. This can happen if the pointers are not properly reassigned during the reversal process.

## Reversing a linked list recursively

Recursion is a programming technique where a function calls itself with different arguments until a certain condition is met. Recursion allows you to solve complex problems by breaking them down into smaller, simpler sub-problems that can be solved recursively.

To reverse a linked list recursively, we need to define a recursive function that takes the head of the linked list as input and returns the new head of the reversed linked list.

Suppose we have the following linked list:

`Loading... `

We first define a recursive function reverseList that takes the head of the linked list as an argument:

In this example, the head of the linked list is the node with value 1.

We check if the head of the linked list is either None or the last node in the linked list (i.e., if it doesn't have a next node). If so, we simply return the head as is:

In this example, the head has a next node (i.e., it's not the last node in the linked list), so we proceed with the recursive call.

We make a recursive call to reverseList with the next node as the new head:

`Loading... `

This will recursively reverse the rest of the linked list and return the new head, which in this example is the node with value 5.

We then set head.next.next to head to reverse the order of the nodes:

`Loading... `

At this point, the linked list looks like this:

`Loading... `

We then set head.next to None to sever the original link between head and its next node:

`Loading... `

At this point, the linked list looks like this:

`Loading... `

We finally return the new head of the reversed linked list, which is the node that was originally the last node in the linked list (i.e., the node that was returned by the last recursive call):

`Loading... `

The final reversed linked list looks like this:

`Loading... `

So the complete code to reverse the linked list recursively would be:

`Loading... `

### Common challenges or errors that can arise:

Reversing a linked list through a recursive approach can present some difficulties and common pitfalls. Here are a few to be aware of:

1. Incorrect Base Case Handling: A frequent mistake is not defining the base case correctly. The base case acts as the stopping point for the recursive function and if not set properly, can result in an infinite loop and cause a stack overflow error.
2. Modifying the Original Linked List: When reversing the linked list, it is crucial to create a new one instead of altering the original. Doing so can result in a corrupted linked list that no longer links to the correct nodes.
3. Losing the Head Pointer: Keeping track of the head pointer is crucial to ensure the linked list is reversed correctly. Losing sight of it can result in a mis-reversed linked list.
4. Improper Updating of Node Pointers: The correct order of updating the node pointers is crucial to a successful reverse. Updating them in the wrong order can result in a mis-reversed linked list.
5. Stack Overflow Error: Recursion generates a new stack frame for each call, and a deep level of recursion can cause a stack overflow error. Optimizing the recursive function and reaching the base case in a timely manner can prevent this.

## Which is better - Reversing a Linked List Recursively or Iteratively?

Deciding whether to use a recursive or iterative approach for reversing a linked list depends on the specific context and requirements. Here are some factors to keep in mind:

1. Efficiency: Iterative methods tend to be more efficient than recursive ones, as they do not involve the overhead of function calls and managing a call stack. If efficiency is a priority, consider using an iterative approach.
2. Memory consumption: Recursive techniques can consume more memory than iterative ones because they necessitate a call stack. If memory usage is a concern, an iterative approach might be more suitable.
3. Clarity: Recursive methods are often more comprehensible and straightforward than iterative ones, as they closely resemble the problem statement. If clarity is important, a recursive approach might be preferable.
4. Ease of maintenance: Recursive methods can be more challenging to maintain and debug than iterative ones due to their increased complexity. If ease of maintenance is a priority, consider using an iterative approach.
5. Support from language and libraries: Certain programming languages and libraries provide better support for recursive methods. If the language or library used has robust support for recursion, a recursive approach might be more appropriate.

In general, if efficiency is a key concern, an iterative approach might be more suitable. However, if the clarity is of greater importance or the problem is inherently recursive, a recursive approach might be the better option.

## Conclusion

In conclusion, reversing a linked list is a way of changing the order of elements in the list so that the last becomes the first, the second-to-last becomes the second, and so on. This is typically done by updating the references in each node to point to the previous node instead of the next one. Iterative solutions use loops and conditionals to execute a block of code repeatedly until a condition is met. They are often more efficient in terms of memory usage and execution time than recursive solutions. Reversing a linked list can be useful in various situations, such as pagination, text editing, routing tables, and audio and video processing.

## Best Practices

Some best practices to keep in mind while reversing a linked list:

1. Handle edge cases: Make sure to handle edge cases such as empty lists, lists with only one node, or lists with circular references.
2. Keep track of three-pointers: To reverse a linked list, you need to keep track of three-pointers: prev, curr, and next. The prev pointer points to the previous node, the curr pointer points to the current node, and the next pointer points to the next node in the original list.
3. Use temporary variables: When updating the pointers of each node, use temporary variables to store the values of the pointers before updating them. This will prevent you from losing access to the original values and will ensure that the reversal is done correctly.
4. Base case: Make sure to define a base case for the recursion. The base case should handle empty or single-node lists, which cannot be further reversed.
5. Check for null values: Always check for null values before accessing any node's pointer. This will prevent your program from crashing due to null pointer exceptions.
6. Examine your code: After completing your code, rigorously test it using various test cases to ensure it functions as intended. Evaluate its performance with diverse linked list scenarios, including lists of varying sizes, circular linked lists, and lists containing repeated values.

## Interview Questions

1. Can you explain the time and space complexity of your iterative linked list reversal algorithm?

Answer: The time complexity of an iterative linked list reversal algorithm is O(n), where n is the number of nodes in the list. The space complexity is O(1), because the algorithm only uses a constant amount of additional memory for the three-pointers.

2. Can you explain the time and space complexity of your recursive linked list reversal algorithm?

Answer: The time complexity of a recursive linked list reversal algorithm is also O(n), where n is the number of nodes in the list. The space complexity is O(n) because the algorithm uses additional memory for the recursive function call stack.

3. How would you handle edge cases such as empty or single-node lists when reversing a linked list?

Answer: When reversing a linked list, it's important to handle edge cases such as empty or single-node lists. For example, you might define a base case to return the head pointer if the list is empty or if it contains only one node.

### Q1: Can you reverse a linked list?

Ans: Yes, a linked list can be reversed by modifying the links between the nodes. The reversal process involves changing the "next" pointers of each node to point in the opposite direction.

### Q2: What is the fastest way to reverse a linked list?

Ans: The fastest way to reverse a linked list is by using an iterative approach. It involves updating the pointers of each node in a single pass.

Related Articles

Top Tutorials