python双链表去重代码

### 回答1：
以下是Python双向链表去重的示例代码：

class Node:
    def __init__(self, value):
        self.value = value
        self.prev = None
        self.next = None
        
class DoublyLinkedList:
    def __init__(self):
        self.head = None
        
    def append(self, value):
        new_node = Node(value)
        if not self.head:
            self.head = new_node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node
            new_node.prev = current
            
    def remove_duplicates(self):
        if not self.head:
            return
        
        current = self.head
        values_seen = set([current.value])
        
        while current.next:
            if current.next.value in values_seen:
                current.next = current.next.next
                if current.next:
                    current.next.prev = current
            else:
                values_seen.add(current.next.value)
                current = current.next
                
    def print_list(self):
        current = self.head
        while current:
            print(current.value, end=' ')
            current = current.next
        print()

# 示例
dllist = DoublyLinkedList()
dllist.append(1)
dllist.append(2)
dllist.append(3)
dllist.append(2)
dllist.append(4)
dllist.append(1)

print("Original List:")
dllist.print_list()

dllist.remove_duplicates()

print("List after removing duplicates:")
dllist.print_list()

上述代码创建了一个双向链表类 `DoublyLinkedList`，其中包括一个用于向链表尾部添加节点的 `append` 方法和一个用于去重的 `remove_duplicates` 方法。在 `remove_duplicates` 方法中，使用了一个集合 `values_seen` 来存储已经出现过的节点值，对于每个节点，如果它的值已经在集合中出现过了，则将它从链表中移除。最后，为了验证去重是否成功，代码还提供了一个 `print_list` 方法来打印链表中的所有节点值。

### 回答2：
双链表是一种数据结构，可以在每个节点中同时保存当前节点的前驱节点和后继节点的指针。在Python中，可以通过定义一个节点类和一个双链表类来实现双链表。

要实现双链表的去重功能，可以遍历链表中的每个节点，并将节点的值存储到一个集合中。如果集合中已经存在了该值，说明该节点是重复的，可以将该节点从链表中删除。代码实现如下：

class Node:
    def __init__(self, data=None):
        self.data = data
        self.prev = None
        self.next = None

class DoublyLinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node
            new_node.prev = current

    def remove_duplicates(self):
        if self.head is None:
            return
        values = set()
        current = self.head
        while current:
            if current.data in values:
                prev_node = current.prev
                next_node = current.next
                if prev_node:
                    prev_node.next = next_node
                if next_node:
                    next_node.prev = prev_node
            else:
                values.add(current.data)
            current = current.next

    def display(self):
        current = self.head
        while current:
            print(current.data, end=" ")
            current = current.next


# 测试样例
if __name__ == "__main__":
    # 创建一个双链表对象
    dllist = DoublyLinkedList()
    
    # 向链表中添加元素
    dllist.append(1)
    dllist.append(2)
    dllist.append(3)
    dllist.append(2)
    dllist.append(4)
    dllist.append(1)
    
    # 去重
    dllist.remove_duplicates()
    
    # 输出链表中的元素
    dllist.display()

以上代码定义了一个Node类和一个DoublyLinkedList类，其中Node类表示双链表的节点，DoublyLinkedList类表示双链表。通过调用remove_duplicates方法，可以实现双链表的去重功能。输出结果为1 2 3 4，是去重后的链表中的元素。

### 回答3：
双链表是一种数据结构，它由多个节点组成，每个节点包含一个数据元素和两个指针，分别指向前一个节点和后一个节点。

要实现双链表去重，可以使用Python编写以下代码：

class Node:
    def __init__(self, data):
        self.data = data
        self.prev = None
        self.next = None

class DoublyLinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node
            new_node.prev = current

    def remove_duplicates(self):
        if self.head is None:
            return

        current = self.head
        visited = set()
        while current:
            if current.data in visited:
                current.prev.next = current.next
                if current.next:
                    current.next.prev = current.prev
            else:
                visited.add(current.data)
            current = current.next

    def display(self):
        if self.head is None:
            print("双链表为空")
            return

        current = self.head
        while current:
            print(current.data, end=" ")
            current = current.next


# 示例用法
dllist = DoublyLinkedList()
dllist.append(1)
dllist.append(2)
dllist.append(3)
dllist.append(2)
dllist.append(4)
dllist.append(2)
dllist.append(5)

dllist.remove_duplicates()
dllist.display()

# 输出结果：1 3 4 5

以上代码定义了一个双链表类`DoublyLinkedList`，其中`append`方法用于在链表尾部添加新节点，`remove_duplicates`方法用于去除重复节点，`display`方法用于输出链表中的节点数据。

在`remove_duplicates`方法中，使用了一个集合`visited`来存储访问过的节点数据，通过遍历链表中的节点，如果节点的数据已经存在于集合中，则将该节点从链表中移除。最终得到的链表中的节点数据就是去重后的结果。