leetcode刷题_day13_（链表）_code82（删除链表中重复的元素）

code82: Remove Duplicates from Sorted List II

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.

Example 1:

Input: 1->2->3->3->4->4->5
Output: 1->2->5
Example 2:

Input: 1->1->1->2->3
Output: 2->3

解答：
1 注意题意，删除重复，只要重复了 自身也会删除。
2 一般情况：
1）重复两次，直接返回node.next.next即可
2）重复多次，需要在后面继续判断。如果还是等于这个value，那么继续返回node.next。
3）观察关系，如果两个后面的继续重复的话，可以在后面再做一个循环，如果等于该值，将操作的node再往后移一位，不等于时，再返回node.next.next即可
3 边界情况：需要考虑 输入为空，以及是否有next和next.next（最后的赋值，如果没有也可辅助，辅助None即可返回直接输出）

根据这个想法，我做的一个新的函数，用作删掉重复。
1如果node.next不等于node.next.next 返回0 和原节点，继续下一个节点。
2如果等于，然后判断，如果没有.next.next.next == None，证明后面没有了而且要全删，则返回 node.next=None
3如果等于，而且.next.next.next ！= None，使node.next = node.next.next.next（也就是说把前两个重复的删了）然后再进行循环，保留value，如果等于，则删除该点。一直循环到不等于。（总结为检查最新的节点 如果等于原本的上一个就删了）

代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        res = operate = ListNode(0)
        res.next = head
        # print(res)
        # print(operate)
        while operate.next != None and operate.next.next != None:
            operate, num = self.dedu(operate)
            if num == 0:
                # print(operate.val)
                operate = operate.next
            elif num == 1:
                continue
            elif num == 2:
                return res.next

        return res.next

    def dedu(self, node):
        value = node.next.val

        if node.next.val != node.next.next.val:
            return node, 0
        else:
            if node.next.next.next == None:
                node.next = None
                return node, 2
            if node.next.next.next != None:
                node.next = node.next.next.next
                # print(node)
                while node.next and node.next.val == value:
                    node.next = node.next.next
                    # node = node.next
                return node, 1

这样意思上说得通，但是代码过于复杂。

按照最初的解答意思进行代码改写。
1 用一个pre作为node的前置点，如果node不等于node.next则都向右移动。
2 如果等于，
1）判断两种情况，一种是两个等于，一个是多个等于
2）默认直接返回node=node,next.next，然后将node赋值pre.next（这样就删掉了两个点）
3）对于多个的情况，循环，如果等于前置点，node=node.next。后面接默认情况，则可以删除多个点
代码：

class Solution:###OLT
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        pre = ListNode(0)
        pre.next = head
        res = pre

        while head and head.next:
            if head.val != head.next.val:
                pre = pre.next
                head = head.next
            else:
                while head.next and head.next.next:
                    if head.next == head.next.next:
                        head = head.next
                    else:
                        break
                head = head.next.next
                pre.next = head
        return res.next

tips：
1 可以使用pre前置链表进行赋值其next的操作
2 多重嵌套内循环
3 边界情况
4 其实两种方法时间复杂度基本一致，但是后者看起来更简洁。