Linked list problems show up in phone screens and online assessments because they are short to state but easy to get wrong. The good news is that almost every one of them is a variation of a handful of patterns. If you can recognize the pattern in the first minute, the rest is careful pointer work.
1. Fast and slow pointers
Move one pointer one step and another two steps. When the fast pointer reaches the end, the slow one is at the middle. The same idea detects a cycle (the pointers meet) and finds where the cycle starts (reset one pointer to the head and move both one step until they meet again). Typical questions: middle of the list, linked list cycle, palindrome linked list.
2. Reversal in place
Keep three references: prev, curr and next. Save curr.next, point curr.next to prev, then advance. Practice this until you can write it without thinking, because it is a building block for reversing a sublist, reversing in groups of k, and checking palindromes.
3. Dummy head node
Whenever the head itself might change (removing elements, merging, partitioning), create a dummy node that points to the head and return dummy.next at the end. It removes a whole class of edge-case bugs.
4. Two-pointer gap
To remove the nth node from the end, move one pointer n steps ahead, then move both until the first hits the end. The second is now just before the node to delete.
5. Merge
Merging two sorted lists is a loop with a tail pointer. Merging k sorted lists is the same thing with a min-heap, giving O(N log k).
How to talk through it
Draw the list with three or four nodes, name your pointers out loud, and walk through one iteration before you write code. Always test an empty list, a single node and two nodes. Interviewers care much more about that discipline than about speed.
If you want help staying structured during a live coding round, Linkjob AI interview assistant can give real-time hints based on the problem on your screen. (Disclosure: I work on Linkjob AI.)