Remove Duplicates from Sorted List II

Given a sorted linked list, delete all duplicates such that each element appear only once.

For example,
Given 1->1->2, return 1->2.
Given 1->1->2->3->3, return 1->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==NULL || head->next==NULL)
            return head;
        ListNode *p=head,*q=p->next;
        while(q!=NULL){
            if(p->val==q->val && q->next==NULL){ //相等的节点正好为尾节点，则将p->next置为0，返回即可
                p->next=NULL;
                break;
            }
            if(p->val==q->val)
                q=q->next;
            else{
                p->next=q;
                p=p->next;
                q=q->next;
            }
        }
        return head;
    }
};

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.

Subscribe to see which companies asked this question

这个题我用一次遍历来做。p和q来判断是否出现重复的元素。tmp记录p的前一个有效的节点。题目中的例子都可以通过，但是[1,1]的输入会出现Runtime Error，暂时还没有找到原因，代码如下；

/**
 * 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, *q=p->next,*tmp=p;
        bool flag=false;
        while(q!=NULL){
            while(p->val==q->val){
                p=q;
                q=q->next;
                flag=true;
            }
            if(flag){
                if(head==tmp){
                    head=q;
                    tmp=q;
                }
                p=q;
                q=q->next;
                flag=false;
            }
            else{
                tmp=p;
                p=q;
                q=q->next;
            }
        }
        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;
        while(p->next!=NULL && p->val==p->next->val)
            p=p->next;
        if(p!=head){
            while(head!=p->next){
                ListNode *tmp=head;
                head=head->next;
                free(tmp);
            }
            return deleteDuplicates(p->next);
        }
        head->next=deleteDuplicates(head->next);
        return head;
    }
};