82. 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.

1、非递归思路（不带头结点）：

这种方法最难，因为没有头结点，要是一开始就有重复的就很难删除，不过可以借助标志位，一定要注意谢谢测试用例，比如 1 1    1 1 2      1 1 2 2     等

2、递归思路：

如果第一个结点和第二个结点不一样，则第一个结点可以直接作为新链表的头结点，后面继续删除重复的过程；如果第一个结点和第二个结点相同，则需要继续遍历，直到找到第一个与第一个结点不同的结点作为新链表的头结点，如果找不到，说明链表所有结点元素都一样，新链表为NULL，否则从新的头结点出发，继续删除重复的过程。

3、非递归思路：

新建链表头结点指针pDel，pDel->next=head，并设置指针prev指针指向pDel，curr指针指向head->next（代表遍历指针）;当curr->next不为NULL，如果curr->next->val == curr->val，curr=curr->next；如果curr->next->val != curr->val；则需判断prev->next==curr？如果是，则prev=curr；如果不是，则prev->next=curr->next.（这里是说，prev先假设一个next指针，即curr=curr->next；当进行下一步判断时，如果curr->next->val != curr->val 且 prev->next==curr，则说明假设正确，prev直接指向curr）

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        int flag1 = 0, flag2 = 0;
        if (head == NULL || head->next == NULL)
        {
            return head;
        }
        while (head->next != NULL && head->val == head->next->val)
        {
            head = head->next;
            flag1 = 1;
        }
        if (head->next == NULL)
        {
            if (flag1 == 1)
            {
                head = head->next;
                flag1 = 0;
            }
            return head;
        }

        ListNode *p = head;
        ListNode *q = head->next->next;

        while (q != NULL)
        {
            if (p->next->val == q->val)
            {
                p->next->next = q->next;
                delete q;
                q = p->next->next;
                flag2 = 1;
            }
            else
            {
                if (flag2 == 1)
                {
                    delete p->next;
                    p->next = q;
                    q = q->next;
                    flag2 = 0;
                }
                else
                {
                    p = p->next;
                    q = q->next;
                }

            }

        }

        if (flag1 == 1 && flag2 == 0)
        {
            head = head->next;
            flag1 = 0;
        }
        else if (flag2 == 1 && flag1 == 0)
        {
            p->next = NULL;
            flag2 = 0;
        }
        else if (flag1 == 1 && flag2 == 1)//1 1     1 1 2 2     1 1 2
        {
            delete p->next;
            p->next = NULL;
            head = head->next;
            flag1 = 0;
            flag2 = 0;
        }

        return head;

    }
};

/**
 * 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 || head->next == NULL)
        {
            return head;
        }
        ListNode *p = head->next;

        if (p->val != head->val)
        {
            head->next = deleteDuplicates(p);
            return head;
        }
        else
        {
            while (p != NULL && p->val == head->val)
            {
                p = p->next;
            }
            return deleteDuplicates(p);
        }
    }
};

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head==NULL || head->next==NULL)
            return head;

        ListNode *pDel=new ListNode(0);
        pDel->next=head;
        
        ListNode *prev=pDel;
        ListNode *curr=prev->next;
        
        while(curr->next){
            if(curr->next->val!=curr->val){
                if(prev->next==curr)
                    prev=curr;
                else
                    prev->next=curr->next;
            }
            curr=curr->next;
        }
        
        if(prev->next!=curr)
            prev->next=curr->next;
        
        return pDel->next;
    }
};