leetcode 删除有序链表中的重复元素

最新推荐文章于 2024-05-27 20:06:10 发布

原创最新推荐文章于 2024-05-27 20:06:10 发布 · 5.1k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #链表 #基本算法

基本算法专栏收录该内容

23 篇文章

订阅专栏

本文深入探讨了删除有序链表中的重复元素的基本问题及其高级应用，包括如何仅保留出现一次的元素。详细解释了识别和处理重复元素的算法，并通过示例代码演示了解决方案。

问题描述：

https://oj.leetcode.com/problems/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.

问题分析：

基本问题，有序的单链表所有的重复元素都集中在一起，虽然含有重复元素但是每个元素都要保留

所以识别重复元素比较容易，该题也就容易解答。只需要建立一个新的表头就可以很容易的解决该问题。

链表的识别： cur->val == tail->val ? duplicate : distinct.

初始条件的设定：

示例代码：

ListNode *deleteDuplicates(ListNode *head) 
    {
        ListNode node(0), *tail, *p, *cur;
        if (!head || !head->next)
        {
            return head;
        }
        node.next = head;
        tail = head;
        p = head->next;
        while (p)
        {
            cur = p; p = p->next;
            if (cur->val != tail->val)
            {   tail->next = cur; tail = cur;   }
            else
            {   delete cur;   }
        }
        tail->next = NULL;
        return node.next;
    }

问题描述：

有序的单链表删除链表中重复元素只保留出现一次的元素。

https://oj.leetcode.com/problems/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.

问题分析：

需要先识别出重复元素再删除，识别重复元素如下

ListNode *p = head;
(p && p->next && p->val == p->next->val) ？ duplicate : distinct
{ /* p->val 是重复元素 */ }

示例代码：

ListNode *start, *end;
start = end = head; 
bool duplicate = false;
ListNode node, *tail = &node;
while (end)
{
    while (start->val == end->val) /* 识别重复元素 */
    { 
     end = end->next;
     if (end->val == start->val)
	 {	duplicate = true;	}
    }
    if (duplicate) /* 对重复元素的处理 */
	{
		while (start != end)
		{ cur = start; start = start->next; delete cur;  }
	}
    else { tail->next = start; tail = start; start = start->next; }
}
return node.next;

以上代码中有严重的bug

修正如下：

ListNode *deleteDuplicates(ListNode *head) 
    {
        if (!head || !head->next)
        {
            return head;
        }
        ListNode *p = head;
        ListNode node(0), *tail = &node;
        while (p->next)
        {
            if (p->val == p->next->val) /* 重复元素的处理：找出所有的重复元素，略过 */
            {
                int v = p->val; 
                p = p->next->next;
                for (; p && p->val == v; p = p->next);
                if (!p) return node.next;
            }
            else  /* 单一元素添加到新表中 */
            {
                tail->next = p; tail = p;
                p = p->next;
                tail->next = NULL;
            }
           
        }
        tail->next = p;
        return node.next;
    }