Here is a Python solution using a dummy head and two pointers:

```python
class ListNode:
def __init__(self, x):
self.val = x
self.next = None

def deleteDuplicates(head):
dummy = ListNode(0)
dummy.next = head
pre = dummy
cur = head
while cur and cur.next:
if cur.val == cur.next.val:
val = cur.val
while cur and cur.val == val:
cur = cur.next
pre.next = cur
else:
pre = cur
cur = cur.next
return dummy.next
```

Here is a step-by-step explanation of the code:

1. Create a dummy node and set its next node as the head of the linked list. This is to handle the edge case where the head node might be deleted.

2. Initialize two pointers, `pre` and `cur`, to the dummy node and the head node respectively.

3. Start a while loop that continues as long as `cur` and `cur.next` are not `None`. This is to ensure that we don't access a `None` node's value, which would raise an error.

4. Inside the loop, check if the current node and the next node have the same value. If they do, then we have found a duplicate.

5. If a duplicate is found, start another loop to skip all nodes with the same value. After this inner loop, `cur` will either be `None` or a node with a different value.

6. Set `pre.next` to `cur` to remove the duplicates from the list.

7. If no duplicate is found, move `pre` and `cur` one step forward.

8. After the loop, return `dummy.next` as the head of the modified list. The dummy node itself is not part of the original list, so we return its next node.

Question

Here is a Python solution using a dummy head and two pointers:

```python
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

def deleteDuplicates(head):
    dummy = ListNode(0)
    dummy.next = head
    pre = dummy
    cur = head
    while cur and cur.next:
        if cur.val == cur.next.val:
            val = cur.val
            while cur and cur.val == val:
                cur = cur.next
            pre.next = cur
        else:
            pre = cur
            cur = cur.next
    return dummy.next
```

Here is a step-by-step explanation of the code:

1. Create a dummy node and set its next node as the head of the linked list. This is to handle the edge case where the head node might be deleted.

2. Initialize two pointers, `pre` and `cur`, to the dummy node and the head node respectively.

3. Start a while loop that continues as long as `cur` and `cur.next` are not `None`. This is to ensure that we don't access a `None` node's value, which would raise an error.

4. Inside the loop, check if the current node and the next node have the same value. If they do, then we have found a duplicate.

5. If a duplicate is found, start another loop to skip all nodes with the same value. After this inner loop, `cur` will either be `None` or a node with a different value.

6. Set `pre.next` to `cur` to remove the duplicates from the list.

7. If no duplicate is found, move `pre` and `cur` one step forward.

8. After the loop, return `dummy.next` as the head of the modified list. The dummy node itself is not part of the original list, so we return its next node.

Knowee AI · Accepted Answer