A singly linked list is a chain of Node { value, next } cells where the list itself stores only a head pointer. Prepending in O(1) is the linked list's headline win over arrays: build a new node whose next points at the current head, then reseat head. The toArray helper makes the list inspectable in tests and the chained prepend mirrors immutable list APIs from functional languages. Storing size is optional but pays for itself the first time a caller asks for length.

Adding a tail pointer keeps append O(1) without sacrificing the O(1) prepend. The remove(value) walk is the place most interview candidates trip: deleting the head requires reseating this.head, deleting the tail requires reseating this.tail, and deleting an interior node requires the predecessor's next to skip the doomed cell. Tracking prev as we walk makes all three cases explicit. Returning a boolean lets the caller distinguish 'removed' from 'not found' without throwing.

Reversing a linked list in place is the canonical pointer-juggling exercise. The pattern keeps three pointers: prev (the new head being built), curr (the node being moved), and next (saved before we overwrite curr.next). Each iteration flips one link without losing track of the rest of the list. The runtime is O(n) and the extra space is O(1), strictly better than building a reversed copy. Memorise this exact body; it shows up in 'reverse linked list', 'reverse in groups of K', and the second half of palindrome-list.