python解决给定一个没有排序的链表，去掉其重复项 ， 并保留原顺序

"""
给定一个没有排序的链表，去掉其重复项 ， 并保留原顺序，例如链表 1 -> 3 -> 1 -> 5 -> 5 -> 7,
去掉重复项后变为 l -> 3 -> 5 -> 7 。
"""
## 方法一
"""
方法一：顺序删除
主要思路为 ： 通过双重循环直接在链表上进行删除操作 。 外层循环用一个指针从第一个
结点开始遍历整个链表，然后内层循环用另外一个指针遍历其余结点 ， 将与外层循环遍历到
的指针所指结点的数据域相同的结点删除。
"""
class LNode:
    def __init__(self):
        self.data = None  # 数据域
        self.next = None  # 指针域
        
def removeDup(self,head):
    """
    方法功能：对带头结点的无序单链表删除重复的结点
    输入参数：head：链表头结点
    """
    if head == None or head.next == None:
        return  
    outerCur = head.next  # 用于外层循环，指向链表第一个结点
    innerCur = None  # 用于内层循环来遍历outerCur后面的结点
    innerPre = None  # innerCur的前驱结点
    
    while outerCur != None:
        innerCur = outerCur.next
        innerPre = outerCur
        while innerCur != None:
            # 找到重复的结点并删除
            if outerCur.data == innerCur.data:
                innerPre.next = innerCur.next
                innerCur = innerCur.next
            else:
                innerPre = innerCur
                innerCur = innerCur.next
        outerCur = outerCur.next

  
if __name__ == '__main__':
    i = 1
    head = LNode()
    tmp = None
    cur = head
    while i < 7:
        tmp = LNode()
        if i % 2 == 0:
            tmp.data = i + 1
        elif i % 3 == 0:
            tmp.data = i - 2
        else:
            tmp.data = i
        cur.next = tmp
        cur = tmp
        i += 1
        
    print('删除重复结点前：', end=' ')
    cur = head.next
    while cur != None:
        print(cur.data, end=' ')
        cur = cur.next
            
    head.removeDup(head)
    print('删除重复结点后：', end=' ')
    cur = head.next
    while cur != None:
        print(cur.data, end=' ')
        cur = cur.next

删除重复结点前： 1 3 1 5 5 7 删除重复结点后： 1 3 5 7
由于这种方法采用双重循环对链表进行遍历，因此，时间复杂度为 O($ N^2 $），其中， N 为链
表的长度，在遍历链表的过程中，使用了常量个额外的指针变量来保存当前遍历的结点、前
驱结点和被删除的结点，因此，空间复杂度为 0(1 ）。

方法二

"""
方法二：递归法
主要思路为 ： 对于结点 cur，首先递归地删除以 cur.next 为首的子链表中重复的结点，接
着从以 cur.next 为首的子链表中找出与 cur 有着相同数据域的结点井删除，
"""

class LNode:
    def __init__(self):
        self.data = None  # 数据域
        self.next = None  # 指针域

def removeDupRecursion(head):
    if head.next is None:
        return head
    pointer = None
    cur = head
    # 对以 head.next 为首的子链表删除重复的结点
    head.next = removeDupRecursion(head.next)
    pointer = head.next
    # 找出以 head.next 为首的子链表中与 head 结点相同的结点并删除
    while pointer is not None:
        if head.data == pointer.data:
            cur.next= pointer.next
            pointer= cur.next
        else:
            pointer = pointer.next
            cur = cur.next
    return head

def removeDup(head):
    """
    方法功能：对带头结点的单链删除重复结点输入参数： head：链表头结点
    """
    if (head is None):
        return
    head.next= removeDupRecursion(head.next)

if __name__ == '__main__':
    i = 1
    head = LNode()
    tmp = None
    cur = head
    while i < 7:
        tmp = LNode()
        if i % 2 == 0:
            tmp.data = i + 1
        elif i % 3 == 0:
            tmp.data = i - 2
        else:
            tmp.data = i
        cur.next = tmp
        cur = tmp
        i += 1
        
    print('删除重复结点前：', end=' ')
    cur = head.next
    while cur != None:
        print(cur.data, end=' ')
        cur = cur.next
            
    removeDup(head)
    print('删除重复结点后：', end=' ')
    cur = head.next
    while cur != None:
        print(cur.data, end=' ')
        cur = cur.next

删除重复结点前： 1 3 1 5 5 7 删除重复结点后： 1 3 5 7 
这种方法与方法一类似，从本质上而言，由于这种方法需要对链表进行双重遍历，因此，
时间复杂度为 O(N2），其中， N 为链表的长度。由于递归法会增加许多额外的函数调用，因此，从理论上讲，该方法效率比方法一低。

方法三

"""
方法三：空间换时间
通常情况下，为了降低时间复杂度，往往在条件允许的情况下，通过使用辅助空间来实
现。具体而言，主要思路为 ：
( 1 ）建立一个 HashSet, HashSet 中的内容为己经遍历过的结点内容，并将其初始化为空。
(2 ）从头开始遍历链表中的所有结点，存在以下两种可能性 ：
1) 如果结点内 容已经在 HashSet 中，那么删除此结点，继续向后遍历。
2 ）如果结点内容不在 Hash Set 中，那么保留此结点，将此结点内容添加到 Hash Set 中，
继续向后遍历。
"""
class LNode(object):
    def __init__(self, item):
        self.data = item
        self.next = None
 
 
 
def removeDup(head):
    if head == None or head.next == None:
        return
    cur = head.next
    pre = None
    hash_list = list()
 
    while cur != None:
        if cur.data in hash_list:
            pre.next = cur.next
            cur = pre.next
        else:
            hash_list.append(cur.data)
            pre = cur
            cur = cur.next
 
 
if __name__ == "__main__":
    i = 1
    head = LNode(0)
    head.next = None
    tmp = None
    cur = head
    while i < 7:
        tmp = LNode(i)
        if i%2 == 0:
            tmp.data = i+1
        elif i%3 == 0:
            tmp.data = i-2
        else:
            tmp.data = i
        tmp.next = None
        cur.next = tmp
        cur = tmp
        i += 1
    print("删除重复节点前：",end=" ")
    cur = head.next
    while cur != None:
        print(cur.data,end=" ")
        cur = cur.next
    removeDup(head)
    print("删除节点后：",end=" ")
    cur = head.next
    while cur != None:
        print(cur.data,end=" ")
        cur = cur.next

删除重复节点前： 1 3 1 5 5 7 删除节点后： 1 3 5 7