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

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

class MyList {
public:
    MyList();
    ~MyList();
    /*建立*/
    ListNode* CreatNewList(int val);
    /*增*/
    void addNewNodeBack(ListNode* Head, int val);
    ListNode* addNewNodeFront(ListNode* Head, int val);
    void InsertNewNodeIntoList(ListNode* Head, int locate, int val);
    /*刪*/
    void DeleteList(ListNode* Head);
    ListNode* DeleteNode(ListNode* Head, int locate);
    /*查*/
    int CheckNodeData(ListNode* Head, int locate);
    /*改*/
    void ChangeNodeData(ListNode* Head, int locate, int val);
    /*翻轉連結串列*/
    ListNode* MyListReverse(ListNode* Head);
    /*連結串列排序(從小到大)*/
    ListNode* MyListSort(ListNode* Head);
    /*移除重複節點*/
    ListNode* MyListRemoveDuplicateNodes(ListNode* Head);
public:
    void ShowListValue(ListNode* Head);
private:
};

MyList::MyList() {

}

MyList::~MyList() {

}

ListNode* MyList::CreatNewList(int val) {
    ListNode* NewNode = new ListNode(val);
    return NewNode;
}

void MyList::DeleteList(ListNode* Head) {
    ListNode* node;
    while (Head->next != NULL) {
        node = Head->next;
        delete Head;
        Head = node;
    }
    delete Head;
}

void MyList::addNewNodeBack(ListNode* Head,int val) {
    ListNode* NewNode = new ListNode(val);
    while (Head->next != NULL) {
        Head = Head->next;
    }
    Head->next = NewNode;
}

ListNode* MyList::addNewNodeFront(ListNode* Head, int val) {
    ListNode* NewHead = new ListNode(val);
    NewHead->next = Head;
    return NewHead;
}

void MyList::InsertNewNodeIntoList(ListNode* Head, int locate, int val) {
    int offset = 0;
    while (offset != locate-1 && Head->next != NULL) {
        offset++;
        Head = Head->next;
    }
    if (offset == locate-1) {
        ListNode* temp = Head->next;
        ListNode* NewNode = new ListNode(val);
        Head->next = NewNode;
        NewNode->next = temp;
    }
    else {
        std::cout << "locate over the list" << std::endl;
    }
}

ListNode* MyList::DeleteNode(ListNode* Head, int locaet) {
    int offset = 0;
    ListNode* CopyHead = Head;
    ListNode* temp = Head;
    while (offset != locaet - 1 && Head->next != NULL) {
        offset++;
        temp = Head;
        Head = Head->next;
    }
    if (offset == locaet - 1 && locaet != 1) {
        temp->next = Head->next;
        delete Head;
    }
    else if(locaet == 1){
        ListNode* Node = Head->next;
        delete Head;
        return Node;
    }
    else {
        std::cout << "locate over the list" << std::endl;
    }
    return CopyHead;
}

void MyList::ShowListValue(ListNode* Head) {
    while (Head->next) {
        std::cout << Head->val << "->";
        Head = Head->next;
    }
    std::cout << Head->val << std::endl;
}

int MyList::CheckNodeData(ListNode* Head, int locate) {
    int offset = 0;
    int val = 0;
    while (offset != locate - 1 && Head->next != NULL) {
        offset++;
        Head = Head->next;
    }
    if (offset == locate - 1) {
        val = Head->val;
    }
    else {
        std::cout << "locate over the list" << std::endl;
    }
    return val;
}

void MyList::ChangeNodeData(ListNode* Head, int locate, int val) {
    int offset = 0;
    while (offset != locate - 1 && Head->next != NULL) {
        offset++;
        Head = Head->next;
    }
    if (offset == locate - 1) {
        Head->val = val;
    }
    else {
        std::cout << "locate over the list" << std::endl;
    }
}

ListNode* MyList::MyListReverse(ListNode* Head) {
    if (Head == NULL) return NULL;
    ListNode* NewEnd = new ListNode(Head->val);
    NewEnd->next = NULL;
    ListNode* CopyNewNode = NewEnd;
    while (Head->next) {
        Head = Head->next;
        ListNode* NewNode = new ListNode(Head->val);
        NewNode->next = CopyNewNode;
        CopyNewNode = NewNode;
    }
    DeleteList(Head);
    return CopyNewNode;
}

ListNode* MyList::MyListSort(ListNode* Head) {
    if (Head == NULL) return NULL;
    std::vector<int> box;
    ListNode* copyhead1 = Head;
    ListNode* copyhead2 = Head;
    int locate = 0;
    box.push_back(Head->val);
    while (Head->next) {
        Head = Head->next;
        box.push_back(Head->val);
    }
    sort(box.begin(), box.end());
    while (copyhead1->next) {
        copyhead1->val = box[locate];
        locate++;
        copyhead1 = copyhead1->next;
    }
    copyhead1->val = box[locate];
    return copyhead2;
}

ListNode* MyList::MyListRemoveDuplicateNodes(ListNode* Head) {
    std::unordered_set<int> box;
    ListNode* cur = Head;
    while (cur && cur->next) { 
        box.insert(cur->val);
        if (box.count(cur->next->val)) {
            ListNode* DeleteNode = cur->next;
            cur->next = cur->next->next;
            delete DeleteNode;
        }
        else {
            cur = cur->next;
        }
    }
    return Head;
}

int main()
{
    MyList M;
    ListNode* Head;
    Head = M.CreatNewList(1);
    for (int i = 2; i < 11; ++i) {
        M.addNewNodeBack(Head, i);
    }
    M.ShowListValue(Head);
    ListNode* NewHead1 = M.MyListReverse(Head);
    M.ShowListValue(NewHead1);
    M.MyListSort(NewHead1);
    M.ShowListValue(NewHead1);
    ///////////////
    M.InsertNewNodeIntoList(NewHead1, 4, 4);
    M.InsertNewNodeIntoList(NewHead1, 5, 5);
    M.InsertNewNodeIntoList(NewHead1, 6, 6);
    M.InsertNewNodeIntoList(NewHead1, 6, 9);
    M.ShowListValue(NewHead1);
    M.MyListRemoveDuplicateNodes(NewHead1);
    M.ShowListValue(NewHead1);
    ///////////////
    M.DeleteList(NewHead1);
    return 0;
}