31：Remove Duplicates from Sorted List II

最新推荐文章于 2022-03-29 14:58:09 发布

原创最新推荐文章于 2022-03-29 14:58:09 发布 · 175 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

119 篇文章

订阅专栏

本文提供了一种高效的方法来删除已排序链表中的重复元素，确保每个数字只出现一次。通过迭代和递归两种实现方式，实现了O(n)的时间复杂度和O(1)的空间复杂度。

本题解法代码的思想及编写参考了网址https://github.com/soulmachine/leetcode#leetcode题解

题目：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.

解题代码版本一：

//迭代版本
//时间复杂度 O(n)，空间复杂度O(1)
class Solution {
public:
        ListNode* deleteDuplicates(ListNode* head) {
                if (head == nullptr) return head;

                ListNode dummy(-1); // 头结点
                dummy.next = head;
                ListNode *prev = &dummy, *cur = head;
                while (cur != nullptr) {
                        bool duplicated = false;
                        while (cur -> next != nullptr && cur -> val == cur -> next -> val) {
                                duplicated = true;
                                ListNode *temp = cur;
                                cur = cur -> next;
                                delete tmp;
                        }
                        if (duplicated) { //删除重复的最后一个元素
                                ListNode* temp = cur;
                                cur = cur -> next;
                                delete temp;
                                prev -> next = cur;
                        }
                        else {
                                prev -> next = cur;
                                prev = prev -> next;
                                cur = cur -> next;
                        }
                }
                return dummy.next;
        }
};

解题代码版本二：

//递归版本
//时间复杂度O(n)，空间复杂度O(1)
class Solution {
public:
        ListNode* deleteDuplicates(ListNode* head) {
                if (head == nullptr || head -> next == nullptr) return head;
                ListNode* p = head -> next;
                if (head -> val == p -> val) {
                        while (p && head -> val == p -> val) {
                                ListNode* tmp = p;
                                p = p -> next;
                                delete tmp;
                        }
                        delete head;
                        return deleteDuplicate(p);
                }
                else {
                        head -> next = deleteDuplicates(head -> next);
                        return head;
                }
        }
};