【Remove Duplicates from Sorted List II 】cpp

题目：

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.

代码：

/**
 * 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 || !head->next ) return head;
            ListNode dummy(INT_MIN);
            dummy.next = head;
            ListNode *prev = &dummy;
            ListNode *p = head;
            while ( p && p->next )
            {
                if ( p->val!=p->next->val )
                {
                    prev = p;
                    p = p->next;
                }
                else
                {
                    while ( p->next && p->val==p->next->val ) p = p->next;
                    prev->next = p->next;
                    p = p->next;
                }
            }
            return dummy.next;
    }
};

Tips:

主要思路就是：如果遇上相同的，就用while循环一直往后过。

具体思路沿用了之前Python版的：http://www.cnblogs.com/xbf9xbf/p/4186852.html

====================================================

第二次过这道题，思路忘记了。赶紧翻了了一下上面的笔记，才想起来；代码一次AC了。

/**
 * 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 ) return head;
            ListNode dummpy(-);
            dummpy.next = head;

            ListNode* pre = &dummpy;
            ListNode* curr = head;

            while ( curr && curr->next )
            {
                if ( curr->val!=curr->next->val )
                {
                    pre = curr;
                    curr = curr->next;
                }
                else
                {
                    while ( curr->next && curr->val==curr->next->val )
                    {
                        curr = curr->next;
                    }
                    pre->next = curr->next;
                    curr = curr->next;
                }
            }
            return dummpy.next;
    }
};

这里的思路关键点是while循环的判断条件（curr && curr->next）。