用于从未排序的链表中删除重复项的Python程序

编写一个 removeDuplicates()函数，该函数接受一个列表并从列表中删除任何重复的节点。该列表未排序。
例如，如果链表是 12->11->12->21->41->43->21，那么 removeDuplicates() 应该将链表转换为 12->11->21->41->43。

方法 1（使用两个循环）：
这是使用两个循环的简单方法。外循环用于一一选择元素，内循环将选择的元素与其余元素进行比较。
感谢 Gaurav Saxena 帮助编写此代码。

Python3

# Python3 program to remove duplicates
# from unsorted linked list
class Node():    
    def __init__(self, data):        
        self.data = data
        self.next = None
  
class LinkedList():    
    def __init__(self):
          
        # Head of list
        self.head = None
  
    def remove_duplicates(self):        
        ptr1 = None
        ptr2 = None
        dup = None
        ptr1 = self.head
  
        # Pick elements one by one
        while (ptr1 != None and 
               ptr1.next != None):
              
            ptr2 = ptr1
  
            # Compare the picked element with 
            # rest of the elements
            while (ptr2.next != None):
                  
                # If duplicate then delete it
                if (ptr1.data == ptr2.next.data):
                      
                    # Sequence of steps is important here
                    dup = ptr2.next
                    ptr2.next = ptr2.next.next
                else:
                    ptr2 = ptr2.next
                      
            ptr1 = ptr1.next
              
    # Function to print nodes in a 
    # given linked list 
    def printList(self):
        temp = self.head
          
        while(temp != None):
            print(temp.data, end = " ")
            temp = temp.next
              
        print()
          
# Driver code
list = LinkedList()
list.head = Node(10)
list.head.next = Node(12)
list.head.next.next = Node(11)
list.head.next.next.next = Node(11)
list.head.next.next.next.next = Node(12)
list.head.next.next.next.next.next = Node(11)
list.head.next.next.next.next.next.next = Node(10)
  
print("Linked List before removing duplicates :")
list.printList()
list.remove_duplicates()
print()
print("Linked List after removing duplicates :")
list.printList()
# This code is contributed by maheshwaripiyush9

输出：

Linked list before removing duplicates:
10 12 11 11 12 11 10 
Linked list after removing duplicates:
10 12 11

时间复杂度： O(n^2)

方法2（使用排序）：
一般来说，合并排序是最适合有效排序链表的排序算法。
1) 使用合并排序对元素进行排序。我们很快就会写一篇关于排序链表的文章。 O(nLogn)
2）使用在排序的链表中删除重复项的算法在线性时间内删除重复项。在）
请注意，此方法不会保留元素的原始顺序。
时间复杂度： O(nLogn)

方法 3（使用散列）：
我们从头到尾遍历链接列表。对于每个新遇到的元素，我们检查它是否在哈希表中：如果是，我们将其删除；否则我们把它放在哈希表中。

Python3

# Python3 program to remove duplicates 
# from unsorted linkedlist 
class Node:    
    def __init__(self, data):        
        self.data = data
        self.next = None
  
class LinkedList:    
    def __init__(self):        
        self.head = None
          
    # Function to print nodes in a  
    # given linked list 
    def printlist(self):        
        temp = self.head
          
        while (temp):
            print(temp.data, end = " ")
            temp = temp.next
              
    # Function to remove duplicates from a 
    # unsorted linked list 
    def removeDuplicates(self, head):
          
        # Base case of empty list or 
        # list with only one element
        if self.head is None or self.head.next is None:
            return head
              
        # Hash to store seen values 
        hash = set()  
  
        current = head
        hash.add(self.head.data)
  
        while current.next is not None:
            if current.next.data in hash:
                current.next = current.next.next
            else:
                hash.add(current.next.data)
                current = current.next
  
        return head
  
# Driver code 
if __name__ == "__main__":
      
    # Creating Empty list
    llist = LinkedList()
    llist.head = Node(10)
    second = Node(12)
    third = Node(11)
    fourth = Node(11)
    fifth = Node(12)
    sixth = Node(11)
    seventh = Node(10)
      
    # Connecting second and third
    llist.head.next = second
    second.next = third
    third.next = fourth
    fourth.next = fifth
    fifth.next = sixth
    sixth.next = seventh
  
    # Printing data
    print("Linked List before removing Duplicates.")
    llist.printlist()
    llist.removeDuplicates(llist.head)
    print("Linked List after removing duplicates.")
    llist.printlist()
# This code is contributed by rajataro0

输出：

Linked list before removing duplicates:
10 12 11 11 12 11 10 
Linked list after removing duplicates:
10 12 11

感谢 Bearwang 提出这种方法。
时间复杂度：平均 O(n)（假设哈希表访问时间平均为 O(1)）。

有关详细信息，请参阅有关从未排序的链接列表中删除重复项的完整文章！