82. Remove Duplicates from Sorted List II

仅供自己学习

 

思路：

直接迭代即可。这里需要建立一个虚拟头节点 dummy以避免对head进行过多处理和一些细节错误。还建立一个cur用来移动，一个temp用来指cur的前一个位置，用来辅助删掉所有重复的节点。

因为要删掉最后一个重复元素，但这时候他的下一个元素已经不相等了，所以我们使用一个标志来判断这个元素是否是重复元素删掉后剩下的最后一个。

然后开始每次判断cur和cur->next的 val 是否相同，如果相同，就将cur->next =cur->next->next，然后标志位flag=1,然后continue，这样就会让重复元素只剩下最后一个，然后我们判断flag是否为1，如果为1说明这个元素是剩下的最后一个重复元素，这时候我们移动temp->next=cur->next，因为我们的temp是紧跟再cur前一个位置，然后cur=cur->next，这样就能把最后一个重复元素删除。

如果这一段没有重复元素我们就 temp=temp->next,cur=cur->next,将两个指针向右移动。

while循环结束后，还要再判断flag是否==1，然后再将这个重复元素去除，这是个边界例子[1,1]，因为while的循环条件是 temp->next->next不为空，但是[1,1]这个例子删除一个1后，[1]还存在就结束了while循环，但我们需要把他删除，所以还需要在判断一次flag等于1，就主动把他删掉，在返回dummy->next即可。

 

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head==nullptr) return head;
        ListNode* dummy=new ListNode(0,head);
        ListNode* cur=dummy->next;
        ListNode* temp=dummy;
        int flag=0;
        while(temp->next->next){
            if(cur->val==cur->next->val){
                cur->next=cur->next->next;
                flag=1;
                continue;
            }
            if(flag==1){
                temp->next=cur->next;
                cur=cur->next;
                flag=0;
                continue;
            }
            temp=temp->next;
            cur=cur->next;

        }
        if(flag==1){
            temp->next=cur->next;
            cur=cur->next;
            flag=0;
        }
        return dummy->next;
    }
};

 

优化，不用temp，但用cur在temp的位置上，操作next和next->next的元素。

如果遇到连续的元素，在if里面再加个while一直循环将cur->next指向连续元素的最后一个元素的下一个元素即可。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head==nullptr) return head;
        ListNode* dummy=new ListNode(0,head);
        ListNode* cur=dummy;
        while(cur->next&&cur->next->next){
            if(cur->next->val==cur->next->next->val){
                int temp=cur->next->val;
                while(cur->next&&cur->next->val==temp){
                    cur->next=cur->next->next;
                }
            }
            else{
                cur=cur->next;
            }
        }
        
        return dummy->next;
    }
};

 

还有一种递归的方法，不过得先判断head和head->next不为NULL。

然后判断head和head->next是否相等，如果不等就在进入递归函数，因为这样就能继续返回后面处理掉后面有重复元素的链表了。如果相等那么就定义一个cur=head->next节点，如果cur不为空且cur->val=head->val，那么就cur=cur->next，这样一直到不同的元素，然后将这个不同的元素传入递归函数，这个递归函数就会返回后面处理掉重复元素后的链表。这个函数正在处理重复元素，那么调用这个在处理重复元素的函数的应该是上个递归的head->next=递归函数返回的链表（head->next），所以我们正在处理重复元素的函数返回的会是没有重复元素的链表。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(!head||!head->next) return head;
        if(head->val!=head->next->val){
            head->next=deleteDuplicates(head->next);
        }
        else{
            ListNode* cur=head->next;
            while(cur&&cur->val==head->val){
                cur=cur->next;
            }
            return deleteDuplicates(cur);
        }
        
        return head;
    }
};