题目

在一个排序的链表中，存在重复的节点，请删除该链表中重复的节点，重复的节点不保留。

数据范围

链表中节点 val 值取值范围 [0,100][0,100]。
链表长度 [0,100][0,100]。

样例1

输入：1->2->3->3->4->4->5

输出：1->2->5

样例2

输入：1->1->1->2->3

输出：2->3

解析

线性扫描，定义一个虚拟头节点dummy，然后扫描整个链表，如果每扫描元素相同一段，若该段元素个数大于1，将整段删除

代码

C++

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplication(ListNode* head) {
        auto dummy = new ListNode(-1);
        dummy->next = head;
        
        auto p = dummy;
        while (p->next) {
            auto q = p->next;
            while (q && p->next->val == q->val) q = q->next;
            
            // 下一段长度等于1，下一段不用删掉
            if (p->next->next == q) p = p->next;
            else p->next = q;
        }
        
        return dummy->next;
    }
};

Python

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def deleteDuplication(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        dummy = ListNode(-1)
        dummy.next = head
        
        p = dummy
        
        while p.next:
            q = p.next
            while q and p.next.val == q.val:
                q = q.next
            if p.next.next == q:
                p = p.next
            else:
                p.next = q
        return dummy.next

GO

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func deleteDuplication(head *ListNode) *ListNode {
	dummy := &ListNode{Next: head}
	p := dummy 
	for p.Next != nil {
	    q := p.Next
	    for q != nil && p.Next.Val == q.Val {
	        q = q.Next
	    }
	    if p.Next.Next == q {
	        p = p.Next
	    } else {
	        p.Next = q
	    }
	}
	return dummy.Next
}