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.

题目要求：

给一有序链表，删除所有重复数字的结点，只留下出现一次的结点。

解题思路：

与83题不一样的是，这里只要重复的元素都要删除，题目的难点在于新链表头结点的设置。

1、递归思路：

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

2、非递归思路：

新建链表头结点指针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）

参考代码：

/**
 * 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 && p->val==head->val) p=p->next;
            return deleteDuplicates(p);
        }
    }
};

/**
 * 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 *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;
    }
};