Unit 3: Linked Lists

Reverse a list in place by moving links one at a time and explain which variables must be preserved before reassignment.

Use two references moving at different speeds to decide whether a list contains a cycle.

After detecting a cycle, find the node where the cycle starts and justify why the second phase works.

Combine two sorted linked lists into one sorted list without creating new data nodes.

Use two references with a fixed gap so a node can be removed in one pass.

Return the middle node of a linked list and define the expected result for even-length lists.

Rearrange nodes so values below a pivot appear before the others while preserving relative order within each group.

Given a sorted linked list, remove repeated values while keeping one copy of each value.

Given a sorted linked list, remove every value that appears more than once, using a sentinel to handle head removals.

Add numbers represented by reversed digit lists and produce a new list with correct carry propagation.

Determine whether a linked list reads the same forward and backward without converting the entire list to a string.

Transform a list so nodes alternate from the front half and reversed back half.

Move the last k nodes to the front after computing length and handling k larger than the list length.

Swap every adjacent pair of nodes without changing stored values.

Reverse nodes k at a time and leave the final short group unchanged.

Given two singly linked lists that may share node objects, find the first shared node by reference.

Copy a linked structure where each node has next and extra references while preserving relationships.

Sort a linked list using split and merge rather than random indexing.

Build a sorted linked list by inserting each original node into the correct position.

Explain when copying the next node data works and why it fails for the final node.

Flatten nodes that may have child lists into a single linked list in depth-first order.

Implement addFirst, addLast, removeFirst, and removeLast while handling empty and one-node lists.

Create an iterator over a custom linked list that supports hasNext and next without exposing node references.

Use linked nodes to implement enqueue and dequeue while preserving O(1) access to both ends.

Use linked nodes to implement push, pop, and peek with correct empty-list behavior.

Remove every node whose value matches a condition without skipping nodes or losing the remaining list.

Split one list into two lists by alternating nodes and preserving original node order.

Given a sorted linked list, replace each run with one node storing value and count.

Given a flawed insert method, identify the exact assignment that loses the rest of the list.

Design a practice assignment that requires diagrams, implementation, edge-case tests, and runtime explanation.