链接表 List
#ifndef SJTU_LIST_HPP #define SJTU_LIST_HPP #include <cstddef> #include <cstring> #include <string> #include <cstdlib> #include <vector> #include <climits> #include <cstddef> namespace sjtu { class exception { protected: const std::string variant = ""; std::string detail = ""; public: exception() {} exception(const exception &ec) : variant(ec.variant), detail(ec.detail) {} virtual std::string what() { return variant + " " + detail; } }; class index_out_of_bound : public exception {}; class runtime_error : public exception {}; class invalid_iterator : public exception {}; class container_is_empty : public exception {}; template<typename T> class list { private: struct node { node* pre; node* next; T* data; node() { next = NULL; pre = NULL; data = NULL; } ~node() { delete data; } }; node* head; node* tail; int currentsize; public: list() { currentsize = 0; head = new node; tail = new node; head->next = tail; tail->pre = head; head->pre = NULL; tail->next = NULL; } list(const list<T> &other) { currentsize = 0; head = new node; tail = new node; head->next = tail; tail->pre = head; head->pre = NULL; tail->next = NULL; node* tmp = head; node* tmp2 = other.head; for(int i = 1 ; i <= other.currentsize;i++) { tmp->next=new node; tmp->next->pre=tmp; tmp=tmp->next; tmp2=tmp2->next; tmp->data = new T(*(tmp2->data)); currentsize++; } tmp->next = tail; tail->pre = tmp; } ~list() { for(int i = currentsize;i>=1;i--) { node* p = tail->pre; tail->pre=tail->pre->pre; delete p; } delete head; delete tail; } class iterator; class const_iterator; class iterator { friend class list; private: node* p; list<T>* thelist; public: iterator(const list<T>* ptrlist, node* ptrnode) { thelist = (list<T>*)ptrlist; p=ptrnode; } iterator operator++(int) { iterator tmp = *this; p=p->next; return tmp; } iterator& operator++() { p=p->next; return *this; } iterator operator--(int) { iterator tmp = *this; p=p->pre; return tmp; } iterator& operator--() { p=p->pre; return *this; } T& operator*() const { return *(p->data); } bool operator==(const iterator &rhs) const { return p==rhs.p; } bool operator==(const const_iterator &rhs) const { return p==rhs.p; } bool operator!=(const iterator &rhs) const { return p != rhs.p; } bool operator!=(const const_iterator &rhs) const { return p != rhs.p; } T* operator->() { return p->data; } }; class const_iterator { friend class list; private: node* p; list<T>* thelist; public: const_iterator(const list<T>* ptrlist, node* ptrnode) { thelist = (list<T>*)ptrlist; p = ptrnode; } const_iterator operator++(int) { iterator tmp = *this; p=p->next; return tmp; } const_iterator& operator++() { p=p->next; return *this; } const_iterator operator--(int) { const_iterator tmp = *this; p=p->pre; return tmp; } const_iterator& operator--() { p=p->pre; return *this; } T& operator*() const { return *(p->data); } bool operator==(const iterator &rhs) const { return p==rhs.p; } bool operator==(const const_iterator &rhs) const { return p==rhs.p; } bool operator!=(const iterator &rhs) const { return p != rhs.p; } bool operator!=(const const_iterator &rhs) const { return p != rhs.p; } T* operator->() { return p->data; } }; void clear() { for (int i = currentsize;i >= 1;i--) { node* p = tail->pre; tail->pre = tail->pre->pre; delete p; } currentsize = 0; } list<T> & operator=(const list<T> &other) { if (&other == this) return *this; clear(); node* p1 = head; node* p2 = other.head->next; for(int i = 1 ; i <= other.currentsize ; i ++) { p1->next = new node; p1->next->pre = p1; p1 = p1->next; p1->data = new T(*(p2->data)); p2 = p2->next; } tail->pre = p1; p1->next = tail; currentsize = other.currentsize; return *this; } const T & front() const { return *(head->next->data); } const T & back() const { return *(tail->pre->data); } iterator begin() { iterator tmp(this,head->next); return tmp; } const_iterator cbegin() const { const_iterator tmp(this,head->next); return tmp; } iterator end() { iterator tmp(this,tail); return tmp; } const_iterator cend() const { const_iterator tmp(this,tail); return tmp; } bool empty() const { return currentsize == 0; } size_t size() const { return (size_t)currentsize; } iterator insert(iterator pos, const T &value) { if (pos.thelist != this) throw invalid_iterator(); node* tmp = pos.getp(); tmp->pre->next = new node; *(tmp->pre->next->data)=value; tmp->pre->next->pre=tmp->pre; tmp->pre->next->next = tmp; tmp->pre = tmp->pre->next; tmp=tmp->pre; currentsize++; return pos; } iterator erase(iterator pos) { if (pos.thelist != this) throw invalid_iterator(); currentsize--; iterator tmp(this,pos.p->next); node* p = pos.p; if(p==head) { return tmp; } if(p==tail) { return tmp; } p->pre->next = p->next; p->next->pre = p->pre; delete p; return tmp; } iterator erase(iterator first, iterator last) { if (first.thelist != this ||last.thelist != this) throw invalid_iterator(); do { if (first.p == tail) throw invalid_iterator(); first=erase(first); } while (first != last); return first; } void push_back(const T &value) { node* p = new node; p->data = new T(value); p->pre = tail->pre; tail->pre->next = p; tail->pre = p; p->next = tail; currentsize++; } void pop_back() { node* p = tail->pre; tail->pre=tail->pre->pre; tail->pre->next = tail; delete p; currentsize--; } void push_front(const T &value) { node* p0 = head->next; head->next = new node; head->next->data = new T(value); head->next->next = p0; p0->pre = head->next; head->next->pre = head; currentsize++; } void pop_front() { node* p0 = head->next->next; node* p1 = head->next; delete p1; head->next = p0; p0->pre = head; currentsize--; } }; } #endif