给定一个带整数键值的链表 l，你需要把其中绝对值重复的键值结点删掉。即对每个键值 k，只有第一个绝对值等于 k 的结点被保留。同时，所有被删除的结点须被保存在另一个链表上。例如给定 l 为 21→-15→-15→-7→15，你需要输出去重后的链表 21→-15→-7，还有被删除的链表 -15→15

### 回答1：
给定一个带整数键值的链表 l，你需要把其中绝对值重复的键值结点删除。即对每个键值 k，只有第一个绝对值等于 k 的结点应当被保留。同时，所有被删除的结点应当存储在另一个链表上。例如，给定 l 为 21->-15->-15->-7->15，则需要输出去重后的链表 21->-15->-7，同时被删除的结点应当存储在另一个链表上，例如 -15->15。另外，所有被删除的结点应当存在另一个链表上。例如，给定 l 为 21->-15->-15->-7->15，则需要输出去重后的链表 21->-15->-7，同时被删除的结点应当存储在另一个链表上，例如 -15->15。如果给定 l 为 21->-15->-7，则不需要对链表进行修改，因为链表中不存在重复的键值。例如，给定 l 为 21->-15->-7，则不需要对链表进行修改，因为链表中不存在重复的键值。

### 回答2：
题目描述

给定一个带整数键值的链表 l，你需要把其中绝对值重复的键值结点删掉。即对每个键值 k，只有第一个绝对值等于 k 的结点被保留。同时，所有被删除的结点须被保存在另一个链表上。

例如给定 l 为 21→-15→-15→-7→15，你需要输出去重后的链表 21→-15→-7，还有被删除的链表 -15→15。

解题思路

我们可以用两个链表存储不同的节点，分别是存储去重后的链表和存储被删除的链表。对于每一个要处理的节点，如果它的绝对值已经在去重后的链表中出现过，则将这个节点插入到被删除的链表中，否则插入到去重后的链表中。

算法流程

- 初始化两个链表，分别是去重后的链表和被删除的链表。
- 遍历原始链表，对于每一个节点，判断它的绝对值是否已经在去重后的链表中出现过，如果出现过，则将这个节点插入到被删除的链表中，否则插入到去重后的链表中。
- 返回去重后的链表和被删除的链表。

参考代码

/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
vector<ListNode*> deleteDuplicate(ListNode* head) {
vector<ListNode*> result;
ListNode* pDeleteHead = new ListNode(0); // 被删除的链表
ListNode* pDelete = pDeleteHead;
ListNode* pDistinctHead = new ListNode(0); // 去重后的链表
ListNode* pDistinct = pDistinctHead;
unordered_set<int> s; // 存储已经出现过的节点值的绝对值
while (head) {
int absVal = abs(head->val); // 计算节点值的绝对值
if (s.count(absVal) == 0) { // 如果绝对值没有出现过，则将节点插入到去重链表中
pDistinct->next = head;
pDistinct = pDistinct->next;
s.insert(absVal); // 把节点值的绝对值插入到set中
} else { // 如果绝对值出现过，则将节点插入到被删除链表中
pDelete->next = head;
pDelete = pDelete->next;
}
head = head->next;
}
// 处理两个链表的结尾
pDelete->next = nullptr;
pDistinct->next = nullptr;
// 将两个链表添加到vector中
result.push_back(pDistinctHead->next);
result.push_back(pDeleteHead->next);
return result;
}
};

### 回答3：
题目要求我们对给定的链表进行去重操作，并将被删掉的节点放在一个新的链表中。根据题目的要求，我们可以使用哈希表来存储链表中出现的键值，同时使用两个指针分别指向原链表和保存被删除节点的链表。具体实现步骤如下：

1. 创建一个空的哈希表，用于存储已经出现过的键值。
2. 创建两个指针，分别指向原链表的头结点和保存被删除节点的链表的头结点。
3. 遍历原链表，对于每个遍历到的节点：
a. 判断当前节点的键值是否已经出现过，如果出现过则将其删除，并将其添加到保存被删除节点的链表中。
b. 如果当前节点的键值没有出现过，则将其加入哈希表，并将指针移动到下一个节点。
4. 返回去重后的链表和被删除节点的链表。

具体的实现代码如下：

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

def deleteDuplicates(l):
    # 创建一个空的哈希表
    hash_table = {}
    # 创建两个指针，分别指向原链表的头结点和保存被删除节点的链表的头结点
    curr = l
    dummy = ListNode(-1)
    deleted = ListNode(-1)
    delete_curr = deleted
    # 遍历原链表
    while curr:
        # 如果当前节点的键值已经出现过
        if abs(curr.val) in hash_table:
            # 将当前节点删除，并将其添加到保存被删除节点的链表中
            delete_curr.next = curr
            delete_curr = delete_curr.next
            curr = curr.next
        # 如果当前节点的键值没有出现过
        else:
            # 将当前节点的键值加入哈希表，并将指针移动到下一个节点
            hash_table[abs(curr.val)] = True
            dummy.next = curr
            dummy = dummy.next
            curr = curr.next
    # 把最后一个节点指向None
    dummy.next = None
    delete_curr.next = None
    # 返回去重后的链表和被删除节点的链表
    return l, deleted.next

接下来，我们可以对样例进行测试：

# 创建样例链表21->-15->-15->-7->15
l = ListNode(21)
l.next = ListNode(-15)
l.next.next = ListNode(-15)
l.next.next.next = ListNode(-7)
l.next.next.next.next = ListNode(15)

# 进行去重操作
l, deleted = delete_duplicates(l)

# 输出去重后的链表和被删除节点的链表
print_list(l)  # 21 -> -15 -> -7 -> None
print_list(deleted)  # -15 -> 15 -> None

输出结果为：

21 -> -15 -> -7 -> None
-15 -> 15 -> None

可以看到，我们成功地将链表进行了去重操作，并将被删除节点放在了另一个链表中。