Here is a step-by-step solution in Python:

1. First, we need to handle the edge case where the linked list is empty. If the head of the linked list is None, we simply return None.

```python
if not head:
return None
```

2. We create a dummy node and set its next pointer to the head of the linked list. We also create two pointers, prev and curr, and set them to the dummy node and the head of the linked list, respectively.

```python
dummy = ListNode(0)
dummy.next = head
prev = dummy
curr = head
```

3. We start a while loop that continues until curr is not None. Inside the loop, we start another while loop that continues as long as the next node of curr is not None and its value is the same as the value of curr. If this is the case, we move curr to its next node.

```python
while curr:
while curr.next and curr.next.val == curr.val:
curr = curr.next
```

4. After the inner loop, if the next node of prev is not the same as curr, it means we have encountered duplicates. So, we skip all duplicates and link prev to the node after all duplicates. If not, we simply move prev to its next node.

```python
if prev.next != curr:
prev.next = curr.next
else:
prev = prev.next
```

5. Finally, we move curr to its next node and continue the outer loop.

```python
curr = curr.next
```

6. After the outer loop, we return the next node of dummy, which is the head of the modified linked list.

```python
return dummy.next
```

Here is the complete Python function:

```python
def deleteDuplicates(head):
if not head:
return None

dummy = ListNode(0)
dummy.next = head
prev = dummy
curr = head

while curr:
while curr.next and curr.next.val == curr.val:
curr = curr.next

if prev.next != curr:
prev.next = curr.next
else:
prev = prev.next

curr = curr.next

return dummy.next
```

This function takes a linked list and removes all nodes that have duplicate numbers, leaving only numbers that appear once in the original list. It returns the head of the modified linked list.

Question

Here is a step-by-step solution in Python:

1. First, we need to handle the edge case where the linked list is empty. If the head of the linked list is None, we simply return None.

```python
if not head:
    return None
```

2. We create a dummy node and set its next pointer to the head of the linked list. We also create two pointers, prev and curr, and set them to the dummy node and the head of the linked list, respectively.

```python
dummy = ListNode(0)
dummy.next = head
prev = dummy
curr = head
```

3. We start a while loop that continues until curr is not None. Inside the loop, we start another while loop that continues as long as the next node of curr is not None and its value is the same as the value of curr. If this is the case, we move curr to its next node.

```python
while curr:
    while curr.next and curr.next.val == curr.val:
        curr = curr.next
```

4. After the inner loop, if the next node of prev is not the same as curr, it means we have encountered duplicates. So, we skip all duplicates and link prev to the node after all duplicates. If not, we simply move prev to its next node.

```python
    if prev.next != curr:
        prev.next = curr.next
    else:
        prev = prev.next
```

5. Finally, we move curr to its next node and continue the outer loop.

```python
    curr = curr.next
```

6. After the outer loop, we return the next node of dummy, which is the head of the modified linked list.

```python
return dummy.next
```

Here is the complete Python function:

```python
def deleteDuplicates(head):
    if not head:
        return None

dummy = ListNode(0)
    dummy.next = head
    prev = dummy
    curr = head

while curr:
        while curr.next and curr.next.val == curr.val:
            curr = curr.next

if prev.next != curr:
            prev.next = curr.next
        else:
            prev = prev.next

curr = curr.next

return dummy.next
```

This function takes a linked list and removes all nodes that have duplicate numbers, leaving only numbers that appear once in the original list. It returns the head of the modified linked list.

Knowee AI · Accepted Answer