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.

這道題將連結串列中有重複的資料全部去除，第一種方式：使用兩個vector（nodes1和nodes2），遍歷一遍連結串列。如果當前節點的數字不存在第一個nodes1中則將其新增進去，如果已經存在了則將其加入到nodes2中。這樣的話遍歷完成之後，nodes1中存放的資料是不重複的，nodes2中存放的則是nodes1已經存在資料。比如最開始的1->2->3->3->4->4->5，那麼遍歷完成之後，nodes1中存放的有：1、2、3、4、5，而nodes2存放的有：3、4。然後對集合進行求差集運算，求出只存在於nodes1中的而不存在於nodes2的，就是1、2、5.

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(!head) {
            return nullptr;
        }

        vector<int> nodes1;
        vector<int> nodes2;
        vector<int> resultnodes;
        ListNode* result = new ListNode(0);
        ListNode* temp = result;

        while
 
(head) {

            if(find(nodes1.begin(),nodes1.end(),head->val) == nodes1.end()) {//如果不存在則加入到nodes1中
                nodes1.push_back(head->val);
                //cout << "nodes1:" << head->val << endl;
            } else {//如果存在則加入nodes2中
                nodes2.push_back(head->val);
                //cout << "nodes2:" << head->val << endl;
 

            }
            head = head->next;
        }

        //取差集，從小到大的排序才可以
        set_difference(nodes1.begin(),nodes1.end(),nodes2.begin(),nodes2.end(),inserter(resultnodes,resultnodes.begin()));//取兩個set的差集

        for(vector<int>::iterator it=resultnodes.begin();it!=resultnodes.end();it++) {
            //cout << *it << endl;
            ListNode* node = new ListNode(*it);
            temp->next = node;
            temp = node;
        }

        //return nullptr;
        return result->next;

    }
};

第二種是使用兩個指標和一個flag，最初preCur指向一個節點，Cur指向後一個節點。然後開始遍歷，當preCur和Cur相等的時候flag賦值為1，cur繼續向後移動，當preCur和Cur不相等的時候，flag賦值為0，並且讓preCur等於Cur，Cur繼續向後移動，這樣就可以將前面相等的資料全部跳過去。然後如果此時移動過Cur之後還不相等並且flag=0，那麼就可以將preCur加入到最終要返回的連結串列中了。需要注意一下Cur是不是最後一個，如果是的話直接將其加入即可。

#include <iostream>
#include <unordered_set>
#include <set>
#include <algorithm>
#include <vector>

using namespace std;

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {

        if(!head || !head->next) {
            return head;
        }

        ListNode* preCur = head;
        ListNode* cur = head->next;
        ListNode* result = new ListNode(0);
        ListNode* temp = result;
        int flag = 0;
        while(cur) {
            if(preCur->val == cur->val) {//如果相等的話,標記位賦值為1
                flag = 1;
            } else {//不相等，標記為賦值為0，並且如果此時標記為已經為0了，那麼加入最終的連結串列中
                if(flag == 0) {
                    ListNode* node = new ListNode(preCur->val);
                    temp->next = node;
                    temp = node;
                }
                preCur = cur;
                flag = 0;
                if(!cur->next) {//如果下一個沒有內容了，將此時的cur也加入
                    temp->next = cur;
                }
            }
            cur = cur->next;
        }

        return result->next;

        /*if(!head) {
            return nullptr;
        }

        vector<int> nodes1;
        vector<int> nodes2;
        vector<int> resultnodes;
        ListNode* result = new ListNode(0);
        ListNode* temp = result;

        while(head) {

            if(find(nodes1.begin(),nodes1.end(),head->val) == nodes1.end()) {//如果不存在則加入到nodes1中
                nodes1.push_back(head->val);
                //cout << "nodes1:" << head->val << endl;
            } else {//如果存在則加入nodes2中
                nodes2.push_back(head->val);
                //cout << "nodes2:" << head->val << endl;
            }
            head = head->next;
        }

        //取差集，從小到大的排序才可以
        set_difference(nodes1.begin(),nodes1.end(),nodes2.begin(),nodes2.end(),inserter(resultnodes,resultnodes.begin()));//取兩個set的差集

        for(vector<int>::iterator it=resultnodes.begin();it!=resultnodes.end();it++) {
            //cout << *it << endl;
            ListNode* node = new ListNode(*it);
            temp->next = node;
            temp = node;
        }

        return result->next;*/

    }
};

int main() {
    Solution s;

    ListNode node1(1);
    ListNode node2(1);
    ListNode node3(2);
    ListNode node4(2);
    ListNode node5(3);
    ListNode node6(4);

    node1.next = &node2;
    node2.next = &node3;
    node3.next = &node4;
    node4.next = &node5;
    node5.next = &node6;

    ListNode* p = s.deleteDuplicates(&node1);

    while(p) {
        cout << p->val;
        cout << endl;
        p = p->next;
    }

}