leetcode 83|84. Remove Duplicates from Sorted List 1|2-优快云博客

本文链接：https://blog.youkuaiyun.com/liqinzhe11/article/details/78621864

本文介绍两种方法来删除已排序链表中的重复元素，确保每个元素只出现一次。第一种方法通过遍历查找唯一元素，第二种方法利用哈希映射记录节点出现次数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

way-1:find first unique ,and see next is the same or not

way-2: use map

/**
 * 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) 
    {  
        //way-1
        /*
        if(!head)
            return head;
       
        //先找第一个单个的    
        ListNode *p = head;
        ListNode *q = head;
       
        while(1)
        {
            while(q->val == p->val && q->next)
                q=q->next;
         
            if(q->next == NULL && p->val == q->val && p != q)  
            {
                p->next = NULL;
                break;
            }
            else if(q->next == NULL &&  p == q)
            {
                break; 
            }
            p->next = q;
            p = q;
        } 
        return head; 
        */
        
        //way-2
        if(!head)
            return head;
        
        map<int,int> mm;
        mm[head->val]++;
        ListNode *last = head;
        ListNode *nex = head->next;
        
        while(nex)
        {
            if(mm.find(nex->val) == mm.end())
            {
                mm[nex->val]++;
                last->next = nex;
                last = nex;
                nex = last->next;
            }
            else
            {
                nex = nex->next;
            }
        }
        last->next = NULL;
        return head;
    }
};

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.

/**
 * 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)
            return head;
        
        ListNode hhead(-1);
        hhead.next = head;
        ListNode *last = &hhead;
        ListNode *p = head;
        ListNode *q = p->next;
        
        while(q)
        {
            while(p->val == q->val)
            {
                q = q->next;
                if (!q)
                {
                    last->next = NULL;
                    return hhead.next;
                }
            }
            if(q == p->next) //当前没重复
            {
                last = p;
                p = q;
                q = p->next;
            }
            else    //当前有重复
            {
                last->next = q;
                p = q;
                q = p->next;
            }
        }
        return hhead.next;  
    }
};