在带头结点的单链表l中，删除所有值为x的结点

可以使用双指针法，一个指针指向当前结点，另一个指针指向当前结点的前一个结点。遍历链表，如果当前结点的值等于x，则将前一个结点的next指向当前结点的next，然后删除当前结点。如果当前结点的值不等于x，则将两个指针都向后移动一个结点。最后返回头结点的next即可。

具体实现如下：

def remove_elements(head, x):
    dummy = ListNode(0)  # 创建一个虚拟头结点
    dummy.next = head
    prev, curr = dummy, head
    while curr:
        if curr.val == x:
            prev.next = curr.next
            curr = curr.next
        else:
            prev, curr = curr, curr.next
    return dummy.next

时间复杂度为O(n)，空间复杂度为O(1)。

相关问题

删除带头结点单链表 L 中所有值为 X的结点 的代码

删除带头结点单链表 `L` 中所有值为 `X` 的结点的代码可以使用迭代或递归的方式实现。这里给出一种常见的迭代方法，使用两个指针 `prev` 和 `current` 分别表示前一个节点和当前节点：

def delete_nodes(head, value):
    dummy = ListNode(0)  # 创建虚拟头节点，用于处理头节点的情况
    dummy.next = head

    prev = dummy
    current = head

    while current:
        if current.val == value:
            prev.next = current.next
        else:
            prev = current

        current = current.next

    return dummy.next  # 返回新的头节点，链表的实际头已变为第一个非 `value` 节点

# 示例中的ListNode类结构如下：
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

在这个函数中，我们遍历链表，如果遇到值为 `X` 的节点，就跳过它并将其前面的节点指向它的下一个节点。这样就实现了删除操作。

递归删除不带头结点的单链表L中所有值为x的结点

递归删除不带头结点的单链表L中所有值为x的结点，可以按照以下步骤进行：

1. 如果链表为空，则直接返回；
2. 否则，对于当前链表的第一个结点，如果其值为x，则将其删除，并递归删除剩余部分中所有值为x的结点；
3. 否则，递归删除剩余部分中所有值为x的结点。

具体的删除操作可以使用指针进行实现，代码如下：

void deleteNode(ListNode*& node, int x) {
    if (node == nullptr) {
        return;
    }
    if (node->val == x) {
        ListNode* next = node->next;
        delete node;
        node = next;
        deleteNode(node, x);
    } else {
        deleteNode(node->next, x);
    }
}

其中，ListNode是单链表的结点类型，其定义如下：

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

在调用上述函数时，需要传入链表的头结点的指针，例如：

ListNode* head = new ListNode(1);
head->next = new ListNode(2);
head->next->next = new ListNode(3);
head->next->next->next = new ListNode(2);
deleteNode(head, 2);

执行完上述代码后，链表中所有值为2的结点都会被删除。