leetcode 2. 从有序链表和数组中移出重复元素 Remove Duplicates

1. 链表，使重复元素仅出现一次 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.

思路：
关于链表一般有两种实现方式：递归和非递归
递归实现：

    ListNode* h = head;
    if (h == NULL)
        return NULL;
    if (h->next != NULL && h->next->next != NULL && h->val == h->next->val)
        h->next = h->next->next;
    h->next = deleteDuplicates(h->next);
    return h;

因为可能对于存在连续3个以上相同元素时，对于指针的右移需要考虑更多的情况。如下的程序中，当元素1,2相等，当删除第二个元素后，指针右移，此时以第3个元素为起始递归，若第3个元素和第1个元素相等，则出错。要想正确编写，比较复杂。

非递归实现：

/**
 * 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) {
        ListNode* h = head;
        if(h == NULL)
            return NULL;
        ListNode* t = NULL;
        while (h != NULL)
        {
            t = h; //参考指针
            while ((h = h->next) != NULL ) //循环右移，直至不等
            {
                if(t->val == h->val)
                    continue;
                else
                    break;
            }
            t->next = h;
        }
        return head;
    }
};

leetcode 结果：
Submission Details
164 / 164 test cases passed.
Status: Accepted
Runtime: 17 ms

//另一种实现，逐个删除，prev作参考项
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode* prev = head;
        ListNode* cur = head->next;
        for (; cur; cur = cur->next) {
            if (prev->val == cur->val) {
                prev->next = cur->next;
                delete cur;
            } else {
                prev = cur;
            }
        }
        return head;
    }
};

2 链表,移除所有重复元素

问题：给定一个有序链表，将重复的元素全部移除
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.

思路：

2.1 非递归（迭代）版本：

注：prev前一节点，cur当前节点

（1）直观能想到引入节点 prev，但是针对 prev 节点的赋值不容易想到，首先在开始的时候，cur = head，那么 prev 应该赋什么值，如果同样赋head的话，在后面的程序中，需要比较绕的思路，才能做出修正。因此引入一个虚拟节点dummy，使它成为 head节点的 prev 节点。
（2）要解决如何删除重复的节点：由章节1联想是，说整块移除重复节点，那么 对cur节点的后移（cur = cur->next）产生影响，即都移除了，cur指向哪里，prev的移动。因此我们采用保留最开始的参考项，逐个删除参考项后的重复节点，最后在移除参考项。
（3）什么时候 prev 节点会后移？当有重复节点的时候，我们会删除这些节点，故只有当没有重复的时候，prev才后移，因此想到引入标志位–标注是否存在重复。
（4）注意最后的prev->next = NULL; prev的链接就是处理完成之后的链表。

/**
 * 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) {
        ListNode dummy(0);
        if (head == NULL) 
            return NULL;
        ListNode* cur = head;
        ListNode* prev = &dummy;
        dummy.next = head;
        bool duplicate = false;
        while (cur != NULL)
        {
            duplicate = false;
            while (cur->next != NULL && cur->val == cur->next->val)
            {
                duplicate = true;
                ListNode *tmp;
                tmp = cur;
                cur = cur->next;
                delete tmp;
            }
            if (duplicate)
            {
                ListNode *tmp;
                tmp = cur;
                cur = cur->next;
                delete tmp;
                continue;
            }
            prev->next = cur;
            prev = prev->next;
            cur = cur->next;
        }
        prev->next = cur; //NULL
        head = dummy.next;
        return head;
    }
};

Submission Details
166 / 166 test cases passed.
Status: Accepted
Runtime: 14 ms
Submitted: 2 minutes ago

算法时间复杂度$O(n)$，空降复杂度$O(1)$
总结：一定要逐个删除，可以引入虚拟节点，引入标志位标注某些事件的发生

2.2 递归版本

思路：递归实现不容易想象，
对于递归，可以分为存在相同和不存在相同两个区间分别递归
当存在相同时：那么最后应该返回：删除所有相同元素后的结果
当不存在相同时：逐个后移，将不同节点链接到一起，然后返回头指针

class Solution {
public:
    //递归
    ListNode* deleteDuplicates(ListNode* head) {
        if (head == NULL || head->next == NULL)
            return head;
        ListNode* p = head->next;
        if (head->val == p->val) {
            while (p != NULL && head->val == p->val) //将参考项后的逐个删除
            {
                ListNode* tmp;
                tmp = p;
                p = p->next;
                delete tmp;
            }
            delete head; //删除参考项
            return deleteDuplicates(p); //删除相同后的结果
        } else {
            head->next = deleteDuplicates(head->next);//将删除相同后的不同节点链接一起
            return head;
        }
    }
};