设计一个算法，删除单链表中值为x的所有结点。

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

1. 定义两个指针，一个指向当前结点，一个指向前一个结点。

2. 遍历单链表，如果当前结点的值等于x，则删除该结点。

3. 删除结点的方法是将前一个结点的next指针指向当前结点的下一个结点。

4. 如果当前结点不等于x，则将前一个指针指向当前结点。

5. 最后返回链表的头结点。

代码实现如下：

ListNode* deleteNode(ListNode* head, int x) {
    ListNode* pre = NULL;
    ListNode* cur = head;
    while (cur != NULL) {
        if (cur->val == x) {
            if (pre == NULL) {
                head = cur->next;
            } else {
                pre->next = cur->next;
            }
            ListNode* temp = cur;
            cur = cur->next;
            delete temp;
        } else {
            pre = cur;
            cur = cur->next;
        }
    }
    return head;
}

### 回答2：
在单链表中删除某个节点，需要涉及到找到该节点的前一个节点，并将它所指向的下一个节点指向该节点所指向的下一个节点。因此我们可以使用两个指针进行操作。

第一个指针指向头节点，第二个指针指向头节点的下一个节点。然后在进行遍历单链表的同时比较每个节点的值是否等于x。若等于x，则将第二个指针指向下一个节点，在将第一个指针的下一个节点指向第二个指针所指向的下一个节点，从而完成删除。若不等于x，则直接将两个指针都指向下一个节点，继续遍历。

具体步骤如下：

1. 建立两个指针p和q，初始都指向头节点。

2. 遍历单链表，当p的下一个节点不为空时，执行以下步骤：

a. 若p的下一个节点的值等于x，则将q指向p的下一个节点的下一个节点，然后将p的下一个节点指向q。此时删除了值为x的节点。

b. 若p的下一个节点的值不等于x，则将p和q都向下移动一个节点。

3. 返回处理过后的单链表。

下面是具体实现代码：

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

ListNode* deleteNode(ListNode* head, int x) {
    ListNode* p = new ListNode(0); // 头节点
    p->next = head;
    ListNode* q = p;

    while (p->next) { // 判断节点是否为空
        if (p->next->val == x) { // 找到需要删的节点
            ListNode* temp = p->next;
            p->next = temp->next; // 删除节点
            delete temp;
        } else {
            p = p->next;
        }
    }

    return q->next; // 返回处理过后的单链表
}

该算法的时间复杂度为O(n)，空间复杂度为O(1)。

### 回答3：
单链表是一种常见的线性数据结构，由多个节点组成，每个节点包含一个数据元素和指向下一个节点的指针。删除单链表中指定值的节点需要遍历整个链表，找到值为x的节点并删除。

以下是一个简单的算法，用于删除单链表中值为x的所有节点：

1. 遍历单链表，寻找值为x的节点。
2. 根据节点的位置，将该节点的前一个节点的next指针指向下一个节点，从而实现删除操作。
3. 重复步骤1和2，直到删除了所有值为x的节点为止。

代码实现如下：

def delete_node(head,x):
    #特判头结点值为x的情况
    while head is not None and head.val == x:
        head = head.next
    #判断链表是否为空
    if head is None:
        return None
    #遍历链表删除值为x的节点
    cur_node = head
    while cur_node.next is not None:
        if cur_node.next.val == x:
            cur_node.next = cur_node.next.next
        else:
            cur_node = cur_node.next
    return head

该算法时间复杂度为O(n)，其中n是单链表的长度，空间复杂度为O(1)。需要注意的是，如果头结点的值也为x，则需要特判。