c++List容器(随意写的

#include <iostream>
#include<my.hpp>
using namespace std;

void line_feed() {
    cout << endl;
}

template<class T>class List {
public:
    T* a;
    List() { init(); }

    List(T data) {
        init();
        this->push_back(data);
        curr = begin();
    }

    List(List<T>& want) {
        init();
        auto cp = want.begin();
        while (cp != want.end()) {
            sz++;
            curr = curr->insertsurr(cp->data);
            cp = cp->surr;
        }

    }
    List<T>& operator=(List<T>& want) {
        init();
        auto cp = want.begin();
        while (cp != want.end()) {
            sz++;
            curr = curr->insertsurr(cp->data);
            cp = cp->surr;
        }
        return *this;
    }

    ~List() {
        clear();
        delete head;
        delete tail;
    }

    List(initializer_list<T>input) {
        init();
        this->push_back(input);

    }

    const T& operator [](int times) {
        ListNode<T>* cp = begin();
        for (auto i = 0; i < times; ++i)cp = cp->surr;
        return cp->data;
    }
    ListNode<T>* operator++() {
        curr = curr->surr;
        return curr;
    }

    ListNode<T>* operator++(int) {
        curr = curr->surr;
        return curr;
    }

    ListNode<T>* operator--() {
        curr = curr->pre;
        return curr;
    }

    ListNode<T>* operator--(int) {
        curr = curr->pre;
        return curr;
    }

    void unique();

    void push_back(const ListNode<T>* list) {
        sz++;
        tail->pre = tail->pre->insertsurr(list->data);
    }

    void push_back(T data) {
        sz++;
        tail->pre = tail->pre->insertsurr(data);
    }

    void push_back(initializer_list<T>input) {
        for (auto i = input.begin(); i < input.end(); ++i) {
            sz++;
            tail->pre = tail->pre->insertsurr(*i);

        }
    }

    void push_front(const ListNode<T>* list) {
        sz++;
        head->surr = head->surr->insertpre(list->data);
    }

    void push_front(T data) {
        sz++;
        head->surr = head->surr->insertpre(data);
    }

    void push_front(initializer_list<T>input) {
        for (auto i = input.begin(); i < input.end(); ++i) {
            sz++;
            head->surr = head->surr->insertpre(*i);
        }
    }

    ListNode<T>* begin() { return head->surr; }

    ListNode<T>* end() { return tail; }

    auto traverse() {
        ListNode<T>* cp = begin();
        auto s = sz;
        while (s--)
        {
            cout << cp->data << ends;
            cp = cp->surr;
        }
    }
    int find(int begin, int end, T data) {
        int get = begin;
        while (get != end) {
            if (operator[](get++) == data)return get - 1;
        }
        return -1;
    }

    ListNode<T>* find(ListNode<T>* begin, ListNode<T>* end, T data) {
        decltype(begin) get = this->begin();
        while (get != end) {
            if (get->data == data)return  get;
            get = get->surr;
        }
        return get;
    }

    ListNode<T>* current() { return curr; }

    T current_data() { return curr->data; }

    size_t size()
    {
        return sz;
    }
    void insert(ListNode<T>* begin, T data);

    void insert(ListNode<T>* ptr, const ListNode<T>* begin, const ListNode<T>* end) const;

    void insert(ListNode<T>* begin, int site, T data);

    ListNode<T>* remove(ListNode<T>* want);

    ListNode<T>* remove(ListNode<T>* want, int site);

    void clear() {
        decltype(head)ptr = begin();
        while (--sz) {
            ptr = ptr->surr;

            delete ptr->pre;
        }
        curr = head;
    }

    void sorted_unique();

    void insert_sort();

    ListNode<T>* selectMax(ListNode<T>* cp);

    auto search(int begin, int end, T data) {
        int get = end;
        while (get != begin) {
            if (operator[](--get) <= data)break;

        }
        return get + 1;

    }

    void insert_after(ListNode<T>* begin, int site, T data);

    auto generate(List<T>ls) {
        ListNode<T>* a = begin();
        int num = 0;
        while (num != ls.size()) {

            a->data = ls[num++];
            a = a->surr;
        }
    }

    void select_sort();

    void swap(ListNode<T>* ls, ListNode<T>* rs) {
        T t = ls->data;
        ls->data = rs->data;
        rs->data = t;
    }


protected:

    auto init() {
        sz = 0;
        head = new ListNode<T>(), tail = new ListNode<T>();
        head->surr = tail;
        tail->pre = head;
        head->pre = NULL;
        tail->surr = NULL;
        curr = head;
        rpre = tail;
    }


private:

    mutable size_t sz;

    ListNode<T>* head, * tail;

    ListNode<T>* curr, * rpre;
};
template<class T> inline void List<T>::insert(ListNode<T>* begin, T data) {
    decltype(begin)cp(begin);
    sz++;
    cp = cp->insertpre(data);
}

template<class T> inline void List<T>::insert(ListNode<T>* begin, int site, T data) {
    sz++;
    decltype(begin)cp(begin);
    while (site--) { cp = cp->surr; }
    cp->insertpre(data);
}

template<class T> inline void List<T>::insert_after(ListNode<T>* begin, int site, T data) {
    sz++;
    decltype(begin)cp(begin);
    while (site--) { cp = cp->surr; }
    cp->insertsurr(data);
}

template<class T> inline void List<T>::insert(ListNode<T>* ptr, const ListNode<T>* begin, const ListNode<T>* end) const {
    decltype(begin)cp(begin);
    while (cp != end) {
        sz++;
        ptr->insertpre(cp->data);
        cp = cp->surr;
    }
}
template<class T> inline ListNode<T>* List<T>::remove(ListNode<T>* want) {
    decltype(want)& p1 = want->pre;
    decltype(want)& p2 = want->surr;
    p1->surr = want->surr;
    p2->pre = want->pre;
    delete want;
    --sz;
    return p2;
}

template<class T> inline ListNode<T>* List<T>::remove(ListNode<T>* want, int site) {

    while (site--)
        want = want->surr;
    return remove(want);


}

template<class T>void List<T>::unique() {
    int r = 0, site;
    while (r != size()) {
        {int num = this->operator[](r);
        if ((site = find(r + 1, size(), num)) != -1) {
            remove(begin(), site);

        }
        else r++;
        }
    }

}

template<class T>void List<T>::sorted_unique() {
    ListNode<T>* cp = begin(), * nextcp = cp->surr;
    while (nextcp != end()) {
        {
            if (cp->data == nextcp->data) {
                nextcp = nextcp->surr;
                remove(nextcp->pre);
            }
            else {
                cp = nextcp;
                nextcp = nextcp->surr;
            }}
    }

}



template<class T>void List<T>::insert_sort() {
    List<T>newlist(0);
    ListNode<T>* cp = begin();
    size_t s = sz;

    while (s--) {

        int site = newlist.search(0, newlist.size(), cp->data);
        newlist.insert(newlist.begin(), site, cp->data);
        cp = cp->surr;
        //newlist.traverse();
        //cout << newlist.begin()->data;
    }
    newlist.remove(newlist.begin(), 0);
    generate(newlist);



}
template<class T>ListNode<T>* List<T>::selectMax(ListNode<T>* cp) {
    ListNode<T>* where = cp;
    ListNode<T>* other = where;
    T max = where->data;
    while (where != begin()) {
        where = where->pre;
        if (where->data > max)
        {
            max = where->data;
            other = where;
        }
    }
    return other;
}

template<class T>void List<T>::select_sort()
{
    using std::swap;
    ListNode<T>* cp = end()->pre;
    size_t s = sz;
    while (s--) {

        this->swap(cp, selectMax(cp));
        cp = cp->pre;
    }

}

int main()
{
    List<int>a{ 100,5,2,7,4,6,3,1,1,1,5,42,52, };
    a.select_sort();
    a.push_back(3);
    a.push_back(1);

    a.traverse();
    line_feed();
    a.insert_sort();
    a.traverse();



}

#pragma once
template<class T>struct ListNode {
    ListNode() = default;
    ListNode(T data, ListNode<T>* pre = NULL, ListNode<T>* surr = NULL) :pre(pre), surr(surr), data(data) {}
    ListNode<T>* pre, *surr;
    T data;
    ListNode<T>*insertpre(const T& data);
    ListNode<T>*insertsurr(const T& data);
    ListNode<T>* operator++() { this = this->surr; return this; }
    bool operator!=(const ListNode<T>right)const { return &this != right; }
    T operator*() const { return this->data; }    
    ListNode<T>* operator++() const { return this->surr; }
    ~ListNode() {}
};
template<class T>ListNode<T>* ListNode<T>::insertpre(const T& data) {
    ListNode<T>* newptr = new ListNode<T>(data);
    newptr->surr = this;
    newptr->pre = pre;
    pre->surr = newptr;
    pre = newptr;
    return newptr;
}
template<class T>ListNode<T>* ListNode<T>::insertsurr(const T& data) {
    ListNode<T>* newptr = new ListNode<T>(data);
    newptr->surr = surr;
    newptr->pre = this;
    surr->pre = newptr;
    surr = newptr;
    return newptr;
}