【Leetcode】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.

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

error：

开始的考虑方向错误，设置当前值和要删除的值。逻辑有点混乱。

//
//  main.cpp
//  RemoveDuplicatesfromSortedList
//
//  Created by pang stongan on 4/29/15.
//  Copyright (c) 2015 pang stongan. All rights reserved.
//

#include <iostream>
using namespace std;


//Definition for singly-linked list.
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode* deleteDuplicates0(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode* pre = new ListNode(-1000);
        pre->next = head;
        head = pre;
        ListNode* curNode = head;
        int curVal = pre->val;
        while(curNode != NULL) {
//            //单独处理尾节点
//            if(curNode->next == NULL){
//
//            }
            if(curVal == curNode->val){
                pre->next = curNode->next;
            } else {
                curVal = curNode->val;
                pre = curNode;
            }
            curNode = curNode->next;
        }
        return head->next;
    }
    
    ListNode* deleteDuplicates(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode* pre = new ListNode(-1000);
        pre->next = head;
        head = pre;
        ListNode* curNode = head;
        int curVal = curNode->val;
        int count = 1;

        while(curNode != NULL) {
            if(curNode->next == NULL){
                if(count > 1)
                    pre->next = NULL;
                else
                    pre->next = curNode;
                break;
            }
            ListNode* next = curNode->next;
            if(curNode->val == next->val){
                count++;
            } else if(count > 1){
                pre->next = next;
                count = 1;
            } else {
                pre->next = curNode;
                pre = curNode;
                curVal = next->val;
            }
            curNode = next;
        }
        return head->next;
    }
};

int main(int argc, const char * argv[]) {
    Solution sol;
    ListNode* tmp = new ListNode(1);
    ListNode* tmp2 = new ListNode(1);
    ListNode* tmp3 = new ListNode(1);
    ListNode* tmp4 = new ListNode(2);
    ListNode* tmp5 = new ListNode(3);
    ListNode* tmp6 = new ListNode(4);
    ListNode* tmp7 = new ListNode(5);
    tmp->next = tmp2;
    tmp2->next = tmp3;
    tmp3->next = tmp4;
    tmp4->next = tmp5;
//        tmp5->next = tmp6;
//        tmp6->next = tmp7;
    ListNode* ret = sol.deleteDuplicates(tmp);
    while(ret){
        cout <<ret->val <<endl;
        ret = ret->next;
    }
    return 0;
}