How do you reverse a linked list?

You can reverse a linked list by changing the next to previous, previous to current, and current to next.

Reversing a linked list involves reorienting the direction of the 'next' pointers to point to the previous node instead of the next one. This process can be done iteratively or recursively.

In the iterative method, you initialise three pointers: previous, current, and next. The previous pointer starts as null because the first node in the reversed list will end up pointing to null. The current pointer starts at the head of the list. The next pointer is used to temporarily store the next node before changing the current node's pointer.

The process then follows these steps:
1. Store the next node using the next pointer.
2. Change the 'next' of the current node to point to the previous node.
3. Move the previous and current pointers one step forward.

This process is repeated until the current node is null, at which point the previous node will be the new head of the reversed list.

The recursive method is a bit more complex. It involves a function that takes a node and a previous node as parameters. If the current node is null, the previous node is the new head of the list. If not, it saves the next node, changes the current node's 'next' to point to the previous node, and then calls the function again with the next node and current node as parameters.

Both methods effectively reverse the linked list by changing the direction of the 'next' pointers. However, the recursive method uses more stack space and can lead to a stack overflow for large lists, while the iterative method uses constant space. Therefore, the iterative method is generally preferred for reversing linked lists.