A singly linked list stores only next links. To remove a node, you change the next link of the node before it. Every node has a node before it, except the head. So removing the head is a different operation: it changes the variable head, not a next link.

Without a dummy node, the code needs a separate loop for the head, such as while head and head.val == val: head = head.next, and then the usual loop for the rest. The same split appears when you insert at the front, or when you build a new list and do not know its first node yet.

A dummy node is one extra node placed before the head: dummy = ListNode(0, head). The value 0 is never read. Now every real node, including the head, has a node before it. One loop and one rule, prev.next = prev.next.next, remove any node.

prev starts at the dummy node. The loop runs while prev.next exists. At each step, prev.next is the node being checked, and prev is the last node that was kept.

The first 6 equals val, so prev.next = prev.next.next links the dummy to the second 6. prev does not move. The second 6 is now prev.next, and it is removed in the same way. The dummy is now linked to 1.

The values 1 and 2 differ from val, so prev moves forward over each. The next 6 is removed by linking 2 to 3. Then 3 is kept, and prev.next is None, so the loop stops. The result is [1, 2, 3]. The same code returns [1, 2, 3, 4, 5] for [1, 2, 6, 3, 4, 5, 6], which is Example 1 of Remove Linked List Elements (LC 203).

After prev.next = prev.next.next, the new prev.next has not been checked yet. So prev stays where it is, and the else branch moves it only when a node is kept. If prev moved after every step, two equal values in a row would leave the second one in the list. For [1, 6, 6, 2] and val = 6, that code returns [1, 6, 2] instead of [1, 2].

The second trap is the return value. After the first node is removed, the variable head still points at the removed node, and the removed node still links to the rest of the list. For the traced input, return head returns [6, 6, 1, 2, 3]. The dummy node always links to the first kept node, so return dummy.next returns [1, 2, 3].

If every node is removed, dummy.next is None, and the function returns an empty list. This case needs no extra code.

A sentinel is an extra element that is not part of the real data. Its job is to remove a special case at an edge. In a linked list, the sentinel is a node. In an array or a range, it can be a virtual index, a virtual value or a virtual bar. The code never stores it. It only pretends that the element is there.

Missing Ranges (LC 163) gives a sorted array nums, a range lower to upper, and asks for every missing number, written as ranges. A gap before nums[0] and a gap after nums[-1] look like two extra cases. Set prev = lower - 1 before the loop, and let the final value of curr be upper + 1. Then each gap, including the first and the last, is the numbers strictly between prev and curr.

def process_ranges(nums: list[int], lower: int, upper: int) -> list[list[int]]:
    """Missing Ranges: virtual anchors make the first and last gap ordinary.
    Time: O(N) | Space: O(1) extra
    """
    result = []  # Each item is one missing range [first, last]
    prev = lower - 1  # 1. Virtual left anchor: the number just before the range
 
    for i in range(len(nums) + 1):
        # 2. Virtual right anchor: on the final pass, curr is the number just after the range.
        curr = nums[i] if i < len(nums) else upper + 1
 
        # 3. Uniform gap check: the numbers strictly between prev and curr are missing.
        if curr - prev > 1:
            result.append([prev + 1, curr - 1])
 
        # 4. Advance: curr becomes the new left anchor.
        prev = curr
    return result
 

Trace nums = [0, 1, 3, 50, 75], lower = 0, upper = 99. prev starts at -1. curr = 0 gives a difference of 1, so there is no gap. curr = 1 has no gap either. curr = 3 gives [2, 2]. curr = 50 gives [4, 49]. curr = 75 gives [51, 74]. The final curr = 100 gives [76, 99]. The result is [[2, 2], [4, 49], [51, 74], [76, 99]], which is Example 1 of Missing Ranges (LC 163).

An empty nums needs no extra code. The loop runs once with curr = upper + 1, and the result is [[lower, upper]]. The time is O(N) because each number is read once, and the extra space is O(1) besides the result.

Largest Rectangle in Histogram (LC 84) uses the same idea with a bar. After the last bar, the code adds one more bar of height 0. That bar is smaller than every real bar, so it pops all the bars still on the stack, and the code needs no second loop to flush them.

Two traps. First, the offsets: prev = lower or a final curr = upper drops the number at that end of the range, because the gap is computed as prev + 1 to curr - 1. Second, the special-case version: writing separate code for nums[0] and nums[-1] repeats the gap rule three times, and one wrong comparison in any copy gives a wrong answer.

The loop looks at each node once, so the time is O(N). The only extra memory is the dummy node and the variable prev, so the space is O(1).

Use a dummy node when the first node of the answer can change. Remove Nth Node From End of List (LC 19) can remove the head. Merge Two Sorted Lists (LC 21) does not know which list gives the first node. Remove Duplicates from Sorted List II (LC 82) removes every copy of a repeated value, including copies at the start.

In Remove Nth Node From End of List (LC 19), start both pointers at dummy, not at head. The trailing pointer must stop at the node before the one to remove. If the head is removed, only dummy is before it.