试写一算法，删除元素非递减排列的单链表l中所有值相同的元素。即相同元素值只保留一个。

### 回答1：
算法如下：

1. 如果链表为空或只有一个元素，直接返回链表。

2. 定义两个指针p和q，分别指向链表的头结点和第二个结点。

3. 遍历链表，如果p和q指向的结点值相同，则删除q指向的结点，并将q指向下一个结点；否则将p和q同时向后移动一个结点。

4. 重复步骤3，直到q指向链表的尾结点。

5. 返回链表。

代码实现如下：

struct ListNode* deleteDuplicates(struct ListNode* head) {
if (head == NULL || head->next == NULL) {
return head;
}
struct ListNode *p = head, *q = head->next;
while (q != NULL) {
if (p->val == q->val) {
p->next = q->next;
free(q);
q = p->next;
} else {
p = p->next;
q = q->next;
}
}
return head;
}

### 回答2：
算法实现如下：

1. 定义一个指针p指向链表的头节点l，定义另一个指针q指向p的下一个节点。

2. 当q不为空时，执行以下操作：

- 如果p指向的节点的值与q指向的节点的值相同，说明出现了相同元素值，删除q指向的节点，即将p的next指针指向q的next节点，然后释放q节点的内存空间。
- 如果p指向的节点的值与q指向的节点的值不相同，说明没有出现相同元素值，将p指向q，q指向下一个节点。

3. 当q为空时，表示已经遍历完整个链表，结束算法。

这个算法的时间复杂度是O(n)，其中n为链表的长度。

以下是算法的Python实现示例：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def deleteDuplicates(head: ListNode) -> ListNode:
    if not head:
        return head
    
    p = head
    q = head.next
    
    while q:
        if p.val == q.val:
            p.next = q.next
            q = q.next
        else:
            p = q
            q = q.next
    
    return head

通过调用`deleteDuplicates`函数，即可删除给定链表l中所有值相同的元素，只保留一个。

### 回答3：
算法如下：

1. 如果链表l为空或者只有一个节点，则直接返回l。
2. 初始化一个指针prev指向l的第一个节点，一个指针curr指向prev的下一个节点。
3. 使用while循环遍历链表，直到curr指向null为止：
- 如果prev节点的值和curr节点的值相等，则删除curr节点，即prev的next指针指向curr的next节点。
- 如果prev节点的值和curr节点的值不相等，则将prev指向curr节点，并将curr指向curr的下一个节点。
4. 返回删除重复元素后的链表l。