LeetCode 之 Remove Duplicates from Sorted List I II — C++ 实现

Remove Duplicates from Sorted List

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.

给定一个有序链表，删除所有多余的元素，使链表中的每个元素只出现一次。

例如：

给定链表 1->1->2，返回 1->2

给定链表 1->1->2->3->3，返回 1->2->3。

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(!head)
        {
            return NULL;
        }
        
        ListNode *pre = head, *p = head->next, *cur = NULL;
        int lastVal = head->val;
        
        while(p)
        {
            if(p->val == lastVal)//重复，则删除
            {
                cur = p;
                p = p->next;
                pre->next = p;
                delete cur;
                cur = NULL;
            }
            else//不重复
            {
                lastVal = p->val;
                p = p->next;
                pre = pre->next;
            }
        }
        
        return head;
    }
};

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->2->3->3->4->4->5，返回 1->2->5

给定链表 1->1->1->2->3，返回 2->3。

分析：

    从表头开始扫描，遇到重复的元素只删除当前的一个，再下次遇到不重复的元素时将这个最开始重复的元素也删掉即可。注意一直重复到表尾的情况。

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(NULL == head)// 空
        {
            return NULL;
        }
        
        struct ListNode *cur = NULL, *ne = NULL;
        int preVal = 0;
        int isequal = 0;
        
        ListNode *tempHead = new ListNode(0), *pre = tempHead;//新建临时头结点，不用判断是否删除为头
        tempHead->next = head;
        ne = head->next;
        preVal = head->val;
        
        while(ne)
        {
            if(ne->val == preVal)//和前一个节点值相等
            {
                isequal = 1;
                cur = ne;
                ne = ne->next;
                pre->next->next = ne;//pre始终指向当前节点的前两个节点，因为当先节点可能和后面节点重复
                
                delete cur;//删除重复节点
                cur = NULL;
            }
            else
            {
                if(isequal)//前面出现过相等的节点，第一个相等的节点没有删除
                {
                    isequal = 0; //标志清 0
                    cur = pre->next;
                    pre->next = ne;
                    
                    delete cur;
                    cur = NULL;
                }
                else
                {
                    pre = pre->next;
                }
                preVal = ne->val;//从新换成当前节点的新值
                ne = ne->next;
            }
        }
        if(isequal)//前面出现过相等的节点，第一个相等的节点没有删除
        {
            cur = pre->next;
            pre->next = NULL;
            
            delete cur;
            cur = NULL;
        }
        
        head = tempHead->next;
        delete tempHead;
        
        return head;
    }
};