删除单链表的重复结点

可以使用哈希表来实现删除单链表的重复结点。具体步骤如下：

1. 创建一个哈希表，用于存储已经出现过的结点值。
2. 遍历单链表，对于每个结点，判断其值是否已经在哈希表中出现过。
3. 如果该结点的值已经在哈希表中出现过，则将该结点从单链表中删除。
4. 如果该结点的值没有在哈希表中出现过，则将该结点的值加入哈希表中。

代码实现如下：

def remove_duplicates(head):
    if not head:
        return None
    hash_set = set()
    hash_set.add(head.val)
    pre = head
    cur = head.next
    while cur:
        if cur.val in hash_set:
            pre.next = cur.next
        else:
            hash_set.add(cur.val)
            pre = cur
        cur = cur.next
    return head

相关问题

用C语言删除单链表中重复结点，重复结点只保留一个，head是单链表首结点指针

以下是用C语言删除单链表中重复结点，重复结点只保留一个的代码：

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int val;
    struct ListNode *next;
};

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

int main() {
    struct ListNode *head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = 1;
    head->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next->val = 1;
    head->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next->next->val = 2;
    head->next->next->next = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next->next->next->val = 3;
    head->next->next->next->next = NULL;
    head = deleteDuplicates(head);
    while (head != NULL) {
        printf("%d ", head->val);
        head = head->next;
    }
    printf("\n");
    return 0;
}

我的第二个问题是：lua closure factory 完整代码

假设单链表中的元素无序，定义成员函数Delete_wuxuchobgfu，删除单链表中值重复的结点删除，再输出单链表所有结点值

在单链表中删除值重复的节点并保持顺序，我们可以定义一个名为`Delete_andPrint的独特函数`。这个过程通常包含以下几个步骤：

1. 定义一个指向头节点的指针`head`。
2. 如果链表为空，直接返回。
3. 创建两个临时变量`prev`和`current`，分别表示前一个节点和当前节点，初始化为`NULL`和`head`。
4. 遍历链表，对于每个节点：
a. 检查当前节点的值是否与其前一个节点的值相同。
b. 如果相同，将前一个节点的`next`指向前一个节点，使得重复节点被跳过。
c. 否则，将`prev`更新为当前节点。
5. 遍历结束后，打印剩余不重复节点的值。

以下是伪代码形式的实现：

struct ListNode {
    int val;
    ListNode* next;
};

ListNode* Delete_andPrint(ListNode* head) {
    if (head == nullptr || head->next == nullptr) return head; // 如果链表只有一个元素或空

    ListNode* prev = nullptr;
    ListNode* current = head;

    while (current != nullptr) {
        if (prev != nullptr && prev->val == current->val) { // 如果当前值等于前一个值
            prev->next = current->next;
        } else {
            prev = current; // 更新前一个节点
        }

        current = current->next;
    }

    // 打印不重复的节点值
    ListNode* temp = head;
    while (temp != nullptr) {
        cout << temp->val << " ";
        temp = temp->next;
    }
    cout << endl;

    return head; // 返回处理后的头节点
}