remove duplicates numbers (移除单链表中相同的元素)

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

For example,
Given 1->2->3->3->4->4->5, return 1->2->5.
Given 1->1->1->2->3, return 2->3.

要求删除链表中相同的元素，最终只返回链表中不相同的元素。
问题分析
当我看到这个题目的时候，首先第一反应是跟之前的删除链表中的相同的元素1->1->2->3->3, return 1->2->3.一样，然后就想把那些重复的元素和之前的一样一个一个删除。
然后发现问题不是自己想象的那样简单，后来跟同学一讨论，发现可以换一个思路，就是先找到第一次出现重复的数，统计这些重复的数的个数，然后将这些重复的数删掉，然后再去考虑后面是否还有重复的数。
如： 1->2->3->3->4->4->5
首先找到3是重复的数，然后统计重复的3的个数为2，删掉。
再继续看是否还有重复的数，找到4，统计重复的4的个数，删掉
没有重复的数，end

 

/** 

 * Definition for singly-linked list. 

 * struct ListNode { 

 *     int val; 

 *     ListNode *next; 

 *     ListNode(int x) : val(x), next(NULL) {} 

 * }; 

 */ 

class Solution { 

public: 

        ListNode *deleteDuplicates(ListNode *head) { 

             if(head!=NULL){ 

                 ListNode *pre = new ListNode(0);  //save the pre node of head, used to head.val==head->next.val 

                 ListNode *preHead = pre;          //save the list 

                 pre->next = head; 

                 ListNode *curSame = head;          //curSame used to visit the list. 

                 while(head!=NULL){ 

                     int counter = 0;           //save the number of duplicates 

                     while(curSame!=NULL&&curSame->val==head->val){   //count the number of duplicates number in the list 

                         curSame=curSame->next; 

                         counter++; 

                     } 

                     if(counter>1){         //delete the duplicates number 

                         pre->next=curSame; 

                         head = curSame; 

                     } 

                     else if(counter==1){ 

                      //consider the situation: head.val!=head->next.val 

                         pre = head; 

                         head = curSame; 

                     } 

                 } 

                 return preHead->next; 

             } 

             else{ 

                  return head; 

             } 

        } 

    };