链接表 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