DSA · Linked Lists · Part 27 of 28

Curated Problem Catalog

July 2026 · 18 min read

There are hundreds of linked-list problems on the judges and maybe fifty distinct ideas among them. This catalog is those fifty, grouped by the eight patterns from the Interview Pattern Catalog and ordered from easy to hard within each group. Every row names the single insight the problem is actually testing and the post in this series that teaches it. Solve one representative from each pattern and you have covered the space; solve the whole list and nothing in an interview will surprise you.

Difficulty follows LeetCode's own labels: Easy, Medium, Hard. Do not skip the easies — they are where you build the muscle memory that makes the hards feel mechanical.

1. Dummy Head / Sentinel & Deletion

Removal problems where the head itself may go. A sentinel in front removes the special case.

#	Problem	Difficulty	The one insight	Post
203	Remove Linked List Elements	Easy	A dummy before the head means deleting the first node is not special.	sentinels
83	Remove Duplicates from Sorted List	Easy	Compare `cur` and `cur.next`; skip while equal.	traversal
82	Remove Duplicates from Sorted List II	Medium	Delete the entire run; a dummy keeps `prev` valid across it.	partitioning
1474	Delete N Nodes After M Nodes	Easy	Two nested counters: keep m, then unlink the next n.	traversal
2487	Remove Nodes From Linked List	Medium	Reverse, drop any node smaller than the running max, reverse back.	reversal
1171	Remove Zero Sum Consecutive Nodes	Medium	Prefix sums in a hash map; a repeat means splice out the span between.	arithmetic

2. Prev–Cur & Pointer-to-Pointer

In-place edits at a node you found, and the design of a list's own operations.

#	Problem	Difficulty	The one insight	Post
237	Delete Node in a Linked List	Medium	No predecessor? Copy the next node's value in and unlink it.	pitfalls
707	Design Linked List	Medium	Every op is prev–cur surgery; a dummy head simplifies all of them.	singly list
817	Linked List Components	Medium	Count maximal runs whose values are all in the set.	traversal
1019	Next Greater Node In Linked List	Medium	A monotonic stack of indices, resolved as you walk the nodes.	traversal

3. Fast & Slow Pointers

Two speeds expose the middle, a cycle, and pair structure — all in one pass, all in O(1) space.

#	Problem	Difficulty	The one insight	Post
876	Middle of the Linked List	Easy	Slow moves one, fast moves two; slow lands on the middle.	fast & slow
141	Linked List Cycle	Easy	If fast ever meets slow, there is a cycle.	cycle detection
234	Palindrome Linked List	Easy	Find middle, reverse the second half, compare halves.	recursion
142	Linked List Cycle II	Medium	After they meet, a pointer from head meets slow at the entrance.	cycle detection
143	Reorder List	Medium	Split at the middle, reverse the tail, then interleave.	reordering
2095	Delete the Middle Node	Medium	Keep a `prev` for slow so you can unlink the middle.	fast & slow
2130	Maximum Twin Sum	Medium	Reverse the second half; sum node i with its twin.	recursion

4. Fixed-Gap Two Pointers

A constant offset between two cursors turns "from the end" and "intersection" into one pass.

#	Problem	Difficulty	The one insight	Post
160	Intersection of Two Linked Lists	Easy	Switch heads at the end; both walk `a + b` and meet.	traversal
19	Remove Nth Node From End	Medium	Open a gap of n, then walk both; a dummy handles removing the head.	fast & slow
61	Rotate List	Medium	Close the list into a ring, then cut `len - k%len` along.	rotation
1721	Swapping Nodes in a Linked List	Medium	The k-th from start and k-th from end via one fixed gap.	fast & slow
2058	Min/Max Between Critical Points	Medium	Track first and last local extremum; min gap is adjacent extrema.	traversal

5. Reverse a Segment

The three-pointer loop, applied to the whole list, a sub-range, or fixed blocks.

#	Problem	Difficulty	The one insight	Post
206	Reverse Linked List	Easy	Save–rewire–advance; `prev` ends as the new head.	reversal
24	Swap Nodes in Pairs	Medium	k-group reversal with k = 2; a dummy anchors the relinking.	k-group
92	Reverse Linked List II	Medium	Reverse only [m, n]; remember the node before and the future tail.	k-group
369	Plus One Linked List	Medium	Reverse (or recurse) to propagate a carry from the least digit.	arithmetic
445	Add Two Numbers II	Medium	Reverse both (or use stacks) so digits align by place value.	arithmetic
25	Reverse Nodes in k-Group	Hard	Reverse each full block of k; leave a short remainder as is.	k-group

6. Build Two Lists and Stitch

Thread each node onto one of two running chains, terminate, and join.

#	Problem	Difficulty	The one insight	Post
86	Partition List	Medium	Two dummies for <x and ≥x; terminate the second or you cycle.	partitioning
328	Odd Even Linked List	Medium	Odd chain and even chain by position; join odd-tail to even-head.	partitioning
725	Split Linked List in Parts	Medium	Count length, give the first `len % k` parts one extra node.	partitioning
1669	Merge In Between Linked Lists	Medium	Walk to a-1 and b+1, splice the second list into the gap.	partitioning
2181	Merge Nodes in Between Zeros	Medium	Accumulate a running sum, emit a node at each zero boundary.	arithmetic

7. Merge / Divide and Conquer

The dummy-tail two-way merge, and everything built on it: k-way merge, merge sort, sorted conversions.

#	Problem	Difficulty	The one insight	Post
21	Merge Two Sorted Lists	Easy	Dummy tail; splice the smaller head, then attach the remainder.	merging
147	Insertion Sort List	Medium	Maintain a sorted prefix; walk from a dummy to find each slot.	sorting
148	Sort List	Medium	Merge sort is the list sort; bottom-up gives O(1) space.	sorting
109	Convert Sorted List to BST	Medium	Inorder build: consume the list left-to-right as you construct.	sorting
1367	Linked List in Binary Tree	Medium	DFS from every tree node, matching the list as a downward path.	recursion
23	Merge k Sorted Lists	Hard	Min-heap of heads, or pairwise divide and conquer: O(N log k).	merging

8. Hash Map + List & Design

Compose a map for lookup with a list for order. The densest and highest-signal group in interviews.

#	Problem	Difficulty	The one insight	Post
705	Design HashSet	Easy	Separate chaining: an array of buckets, each a small list.	singly list
1290	Binary Number to Integer	Easy	Shift the accumulator left, OR in each bit as you walk.	arithmetic
138	Copy List with Random Pointer	Medium	Weave clones between originals to resolve randoms in O(1) space.	clone
146	LRU Cache	Medium	Hash map to nodes of a doubly linked list; move-to-front on use.	LRU cache
355	Design Twitter	Medium	Per-user tweet lists; merge k of them for the feed.	merging
622	Design Circular Queue	Medium	A ring: head and tail indices, or a circular linked list.	circular
382	Linked List Random Node	Medium	Reservoir sampling: keep each node with probability 1/i.	traversal
1472	Design Browser History	Medium	A doubly linked list of pages; visit truncates the forward tail.	doubly list
430	Flatten a Multilevel Doubly Linked List	Medium	DFS: splice each child list in before continuing on `next`.	flatten
114	Flatten Binary Tree to Linked List	Medium	Reverse-preorder threading, or Morris-style right-spine splicing.	flatten
460	LFU Cache	Hard	Frequency buckets, each a list; track the current min frequency.	LFU cache

A Four-Week Study Order

Do these in order. Each week builds on the last; do not jump to Week 4 designs before reversal and merge are automatic.

Week	Theme	Problems, easy first
1	Fundamentals & traversal	206, 876, 21, 83, 141, 203, 234, 160
2	Pointer surgery & reversal	24, 92, 19, 82, 86, 328, 61, 25
3	Fast–slow, merge, sort, arithmetic	142, 143, 147, 148, 2, 445, 2095, 23
4	Design & advanced structures	146, 138, 622, 1472, 430, 355, 707, 460

The 15-problem shortlist. If you have one evening, not one month, do exactly these and you will have touched every pattern: 206, 92, 25, 21, 23, 19, 141, 142, 876, 234, 143, 148, 86, 138, 146.

The Five You Are Most Likely to Get

Across real phone screens and on-sites, these five dominate. Know exactly what each is probing.

#	Problem	What it is really testing
206	Reverse Linked List	Whether the three-pointer loop is truly automatic, and whether you can also give the recursive version and its O(n) stack cost.
21	Merge Two Sorted Lists	The dummy-tail idiom and clean remainder handling — the primitive behind merge sort and merge-k.
142	Linked List Cycle II	Floyd's algorithm and, crucially, whether you can explain why resetting to the head finds the entrance.
19	Remove Nth From End	The fixed-gap two-pointer trick and the empty/head edge cases a dummy makes disappear.
146	LRU Cache	Composing a hash map with a doubly linked list for O(1) get and put under time pressure — the classic design ask.

Check Yourself

You are given a problem. Pick the optimal technique and its complexity.

How to Practise

The catalog is only useful if you practise it the right way. Four rules turn "I solved it" into "I own it":

Implement from scratch, no IDE. Write on paper or in a blank editor with no autocomplete. If you cannot produce reversal or merge without a compiler holding your hand, you have not learned them — you have memorised their shape.
Re-implement a week later. Spaced repetition is the whole game. A problem you nailed on Monday and cannot start the next Monday was never retained. Cycle the shortlist weekly.
Time-box every attempt. easy ten minutes, medium twenty to twenty-five, hard forty. If you blow the box, read the pattern, then redo it from memory later — do not grind.
State complexity out loud, every time. Finish each solution by naming time and extra space before you look at the editorial. It is the habit that pays off in the room.
Always test empty, one, and two nodes. Every problem here has a degenerate input that breaks a careless solution. Run those three before you call it done.