How do you reverse a singly linked list?

A linked list is like a line of people where each person points at the next one. To reverse it, you walk down the line and ask each person to point at the person behind them instead. You need to remember three people at every step: the one behind you (prev), the one you are talking to (current) and the one ahead (next), so you do not lose the rest of the line when the arrow is turned around.

function reverseList(head) {
  let prev = null; // nothing is behind the first node yet
  let current = head;
  while (current !== null) {
    const next = current.next; // 1. remember the rest of the list
    current.next = prev; // 2. turn this node's arrow around
    prev = current; // 3. move prev forward
    current = next; // 4. move current forward
  }
  return prev; // prev is the old last node, now the head
}

// Build 1 -> 2 -> 3
const list = { val: 1, next: { val: 2, next: { val: 3, next: null } } };
let node = reverseList(list);
const values = [];
while (node) {
  values.push(node.val);
  node = node.next;
}
console.log(values.join(" -> ")); // Output: 3 -> 2 -> 1

• Step 1 must happen before step 2; otherwise you lose the pointer to the remaining nodes.
• When the loop ends, current is null and prev points at the new first node.

1. Iterative with three pointers (above): the standard answer.
2. Recursive: reverse the rest of the list, then make the next node point back to the current one. Elegant, but it uses the call stack.
3. Copy into an array and rebuild: easy to write but wastes O(n) memory, so interviewers usually want one of the first two.

• Overwriting current.next before saving it.
• Returning head at the end (that is now the last node).
• Not handling an empty list or a single node; the loop above handles both.

• How would you reverse only the nodes between positions m and n?
• How do you reverse a list in groups of k?
• How can you check whether a linked list is a palindrome?