写一算法将单链表中值重复的结点删除，使所得的结果链表中所有结点的值均不相同。

算法如下：

1. 定义一个哈希表，用于存储链表中出现过的值。

2. 遍历单链表，对于每个结点，判断其值是否在哈希表中出现过。

3. 如果该值已经出现过，则将该结点从链表中删除。

4. 如果该值没有出现过，则将该值加入哈希表中，并继续遍历下一个结点。

5. 遍历完成后，所得的结果链表中所有结点的值均不相同。

6. 返回结果链表。

代码实现：

void removeDuplicates(ListNode* head) {
    unordered_set<int> hashSet;
    ListNode* curr = head;
    ListNode* prev = nullptr;
    while (curr != nullptr) {
        if (hashSet.count(curr->val)) {
            prev->next = curr->next;
            delete curr;
            curr = prev->next;
        } else {
            hashSet.insert(curr->val);
            prev = curr;
            curr = curr->next;
        }
    }
}

相关问题

写一算法将单链表中值重复的结点删除，使所得 的结果链表中所有结点的值均不相同。

要编写一个算法来删除单链表中值重复的节点，使其结果链表中的所有节点值均唯一，你可以采用这样的步骤：

1. 定义两个指针 `prev` 和 `current`，初始都指向链表的头节点。
2. 创建一个新的空链表 `new_head` 作为结果链表的头部。
3. 使用循环遍历原始链表：
- 当 `current` 指针不为空时：
a. 检查 `current->data` 是否等于 `prev->data`（即当前节点的值是否和前一个节点的值相同）。
b. 如果不同，将 `prev` 指针移到 `current`，然后继续下一次迭代。
c. 如果相同，说明找到一个重复的节点，将 `prev` 更新为其下一个节点并继续遍历，因为重复节点后面的节点都是重复的。
4. 当遍历完成后，`prev` 就会停在最后一个非重复节点处，将其设置为新链表的尾部 (`new_head = prev`)。
5. 返回 `new_head` 作为新的链表头。

def delete_duplicates(head):
    if not head or not head.next:
        return head
    
    new_head = None
    prev = current = head

    while current:
        if current.data != prev.data:
            prev = current
        else:
            while current and current.data == prev.data:
                current = current.next
            prev.next = current
        prev = current
        current = current.next

    return new_head

C++写一算法将单链表中值重复的结点删除，使所得的结果链表中所有结点的值均不相同。

在C++中，可以使用双指针（快慢指针）的方式来解决这个问题。以下是简单的步骤：

// 定义链表节点结构体
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

void removeDuplicates(ListNode* head) {
    if (head == nullptr || head->next == nullptr) {
        return; // 如果链表为空或只有一个元素，无需处理
    }

    ListNode* slow = head;
    ListNode* fast = head->next;

    while (fast != nullptr && fast->next != nullptr) { // 当两个指针都未到达链表尾部
        if (fast->val == slow->val) {
            // 如果当前节点的值等于下一个节点，就跳过这个重复的节点
            fast = fast->next;
        } else {
            // 否则，移动慢指针前进
            slow = slow->next;
        }
        fast = fast->next; // 快指针总是比慢指针多走一步
    }

    if (fast != nullptr && fast->val == slow->val) { // 检查是否需要删除最后一个节点
        slow->next = fast->next;
    }
}

这个算法的工作原理是：慢指针每次走一步，而快指针每次走两步。当快指针遇到重复值时，它会直接越过该节点。当快指针到达链表尾部时，慢指针的位置就是新链表的结尾，之前的重复节点已经被删除。