线性表容器list类模板-C++实现

最新推荐文章于 2023-03-20 12:50:55 发布

透小犹

最新推荐文章于 2023-03-20 12:50:55 发布

阅读量386

点赞数 2

分类专栏：数据结构和算法

本文链接：https://blog.csdn.net/m0_55464171/article/details/116722917

版权

数据结构和算法专栏收录该内容

10 篇文章 0 订阅

订阅专栏

线性表是一种常用的数据类型，本文将用双链表实现一个线性表结构的类模板

1）线性表容器声明

//declear class list
template<typename ElementType>
class list {
private:
	struct DataNode;	//储存数据的结构体类型
	typedef DataNode*NodePtr;	//指向储存数据的指针类型

	NodePtr head, tail;		//数据的头结点，尾结点
	int _size;	//当前线性表的数据量
public:
	//迭代器类型
	class iterator;
	class const_iterator;
	class reverse_iterator;
	class const_reverse_iterator;
	//构造函数和析构函数
	list();
	~list();
	//迭代器相关函数
	iterator begin()const;
	iterator end()const;
	const_iterator cbegin()const;
	const_iterator cend()const;
	reverse_iterator rbegin()const;
	reverse_iterator rend()const;
	const_reverse_iterator crbegin()const;
	const_reverse_iterator crend()const;
	//删除操作函数
	iterator erase(iterator it);
	const_iterator erase(const_iterator it);
	reverse_iterator erase(reverse_iterator it);
	const_reverse_iterator erase(const_reverse_iterator it);
	//插入操作函数
	iterator insert(iterator it, ElementType element);
	const_iterator insert(const_iterator it, ElementType element);
	reverse_iterator insert(reverse_iterator it, ElementType element);
	const_reverse_iterator insert(const_reverse_iterator it, ElementType element);
	//一些常用的方法
	ElementType&back();	//返回线性表的尾部数据
	void clear();	//清除线性表
	bool empty()const;	//如果线性表为空，则返回true，否则返回false
	ElementType&front();	//返回线性表的头部数据
	void pop_back();	//删除线性表的尾部数据
	void pop_front();	//删除线性表的头部数据
	void push_back(ElementType element);	//在线性表尾部插入数据
	void push_front(ElementType element);	//在线性表头部插入数据
	void remove(ElementType const&element);	//删除线性表中所有值为element的数据
	void reverse();	//反转线性表中的元素
	int size()const;	//返回当前线性表的数据量
	void swap(list<ElementType>&object);	//交换两个线性表的所有数据
};

2）存储数据的结构体类型DataNode：双链表节点

template<typename ElementType>
struct list<ElementType>::DataNode {
	typedef DataNode*NodePtr;	//指向储存数据的指针类型
	ElementType data;	//数据域
	NodePtr left, right;	//指针域
	DataNode(ElementType init_element) ;	//构造函数
};

3）迭代器类型声明

//_ITERATOR_BEGIN

template<typename ElementType>
class list<ElementType>::iterator {
private:
	//友元声明：插入和删除操作需要访问数据节点
	friend iterator list<ElementType>::erase(iterator it);
	friend iterator list<ElementType>::insert(iterator it, ElementType element);
	NodePtr PtrL;	//迭代器内储存的数据节点
public:
	iterator(NodePtr init_ptr);	//构造函数
	ElementType&operator*();	//重载解引用运算符
	//重载自增自减运算符：用于迭代器的移动
	iterator operator++();
	iterator operator++(int);
	iterator operator--();
	iterator operator--(int);
	//重载关系运算符：用于判断两个迭代器的位置关系
	bool operator==(iterator it)const;
	bool operator!= (iterator it)const;
	bool operator>(iterator it)const;
	bool operator>=(iterator it)const;
	bool operator<(iterator it)const;
	bool operator<=(iterator it)const;
};

//_ITERATOR_END

4）删除操作：erase()方法的实现

template<typename ElementType>
typename list<ElementType>::iterator list<ElementType>::erase(list<ElementType>::iterator it) {
	if (!_size)return iterator(NULL);	//如果线性表为空，则直接返回
	NodePtr temp;	//储存被移除节点的下一节点的临时变量
	_size--;	//由于移除了当前节点，线性表数据量减一
	//如果迭代器指向线性表头部
	if (begin() == it) {
		temp = head->right;
		temp->left = NULL;
		delete head;
		head = temp;
		return iterator(head);
	}
	//如果迭代器指向线性表尾部
	if (tail == it.PtrL) {
		temp = tail->left;
		temp->right = NULL;
		delete tail;
		tail = temp;
		return iterator(NULL);
	}
	//如果迭代器指向线性表中部
	temp = it.PtrL->right;
	temp->left = it.PtrL->left;
	it.PtrL->left->right = temp;
	delete it.PtrL;
	return iterator(temp);
}

5）删除操作：pop()方法的实现

//删除尾部节点
template<typename ElementType>
void list<ElementType>::pop_back() {
	if (!_size)return;	//如果线性表为空，则直接返回
	_size--;	//由于移除了尾部节点，线性表数据量减一
	//特殊情况：头部节点==尾部节点，即线性表数据量为1
	if (head == tail) {
		delete head;
		head = tail = NULL;
	}
	//一般情况
	else {
		tail = tail->left;
		delete tail->right;
		tail->right = NULL;
	}
}
//删除头部节点
template<typename ElementType>
void list<ElementType>::pop_front() {
	if (!_size)return;	//如果线性表为空，则直接返回
	_size--;	//由于移除了头部节点，线性表数据量减一
	//特殊情况：头部节点==尾部节点，即线性表数据量为1
	if (head == tail) {
		delete head;
		head = tail = NULL;
	}
	//一般情况
	else {
		head = head->right;
		delete head->left;
		head->left = NULL;
	}
}

6）插入操作：insert()方法的实现

template<typename ElementType>
typename list<ElementType>::iterator list<ElementType>::insert(typename list<ElementType>::iterator it, ElementType element) {
	NodePtr create = new DataNode(element);	//根据传入参数创建新节点
	_size++;	//由于插入了新节点，线性表数据量加一
	//如果迭代器指向线性表头部
	if (begin() == it) {
		create->right = head;
		head->left = create;
		head = create;
	}
	//如果迭代器指向线性表尾部
	else if (end() == it) {
		create->left = tail;
		tail->right = create;
		tail = create;
	}
	//如果迭代器指向线性表中部
	else {
		create->left = it.PtrL->left;
		create->right = it.PtrL;
		it.PtrL->left->right = create;
		it.PtrL->left = create;
	}
	return iterator(create);	//返回插入的新节点的迭代器
}

7）插入操作：push()方法的实现

//在线性表头部插入
template<typename ElementType>
void list<ElementType>::push_back(ElementType element) {
	//特殊情况：线性表为空
	if (!_size++) {
		head = new DataNode(element);
		tail = head;
	}
	//一般情况
	else {
		NodePtr PtrL = tail;
		tail = tail->right = new DataNode(element);
		tail->left = PtrL;
	}
}
//在线性表尾部插入
template<typename ElementType>
void list<ElementType>::push_front(ElementType element) {
	//特殊情况：线性表为空
	if (!_size++) {
		head = new DataNode(element);
		tail = head;
	}
	//一般情况
	else {
		NodePtr PtrL = head;
		head = head->left = new DataNode(element);
		head->right = PtrL;
	}
}

8）清空线性表：clear()方法的实现

template<typename ElementType>
void list<ElementType>::clear() {
	NodePtr PtrL, it;
	//遍历整个线性表，删除所有节点
	for (it = head; it != tail;) {
		PtrL = it->right;
		delete it;
		it = PtrL;
	}
	delete tail;
	head = tail = NULL;	//将线性表头部和尾部置空
	_size = 0;	//将线性表数据量置零
}

9）移除所有特定元素：remove()方法的实现

template<typename ElementType>
void list<ElementType>::remove(ElementType const&element) {
	for (auto it = begin(); it != end();)
		//调用了删除操作：erase()方法
		if (element == *it)it = erase(it);
		else it++;
}

10）反转线性表元素：reverse()方法的实现

template<typename ElementType>
void list<ElementType>::reverse() {
	if (!_size || 1 == _size)return;	//如果线性表为空或只有一个元素，则直接返回
	iterator left_ptr(head), right_ptr(tail);	//定义双指针，分别指向线性表头部和尾部
	ElementType temp;
	//如果线性表数据量为偶数
	if (_size | 0)
		for (int count = 0; count != _size / 2; count++) {
			//交换左右指针指向元素的值
			temp = *left_ptr;
			*left_ptr = *right_ptr;
			*right_ptr = temp;
			//左指针向右移动一位，右指针向左移动一位
			left_ptr++;
			right_ptr--;
		}
	//如果线性表数据量为奇数
	else for (; left_ptr != right_ptr; left_ptr++, right_ptr--) {
		//交换左右指针指向元素的值
		temp = *left_ptr;
		*left_ptr = *right_ptr;
		*right_ptr = temp;
	}
}

11）交换两个线性表：swap()方法的实现

template<typename ElementType>
void list<ElementType>::swap(list<ElementType>&object) {
	//交换线性表的头部
	NodePtr temp = head;
	head = object.head;
	object.head = temp;
	//交换线性表的尾部
	temp = tail;
	tail = object.tail;
	object.tail = temp;
}

12）命名空间的使用

//命名空间开始标识符
#ifndef _OC_BEGIN
#define _OC_BEGIN namespace OC{
#endif
//命名空间结束标识符
#ifndef _OC_END
#define _OC_END }
#endif

13）完整代码

//OClist.h
#ifndef OCLIST_H
#define OCLIST_H

#ifndef _OC_BEGIN
#define _OC_BEGIN namespace OC{
#endif

#ifndef _OC_END
#define _OC_END }
#endif

#ifndef NULL
#define NULL 0
#endif

_OC_BEGIN

//declear class list
template<typename ElementType>
class list {
private:
	struct DataNode;
	typedef DataNode*NodePtr;

	NodePtr head, tail;
	int _size;
public:
	class iterator;
	class const_iterator;
	class reverse_iterator;
	class const_reverse_iterator;

	list();
	~list();

	iterator begin()const;
	iterator end()const;
	const_iterator cbegin()const;
	const_iterator cend()const;
	reverse_iterator rbegin()const;
	reverse_iterator rend()const;
	const_reverse_iterator crbegin()const;
	const_reverse_iterator crend()const;

	iterator erase(iterator it);
	const_iterator erase(const_iterator it);
	reverse_iterator erase(reverse_iterator it);
	const_reverse_iterator erase(const_reverse_iterator it);

	iterator insert(iterator it, ElementType element);
	const_iterator insert(const_iterator it, ElementType element);
	reverse_iterator insert(reverse_iterator it, ElementType element);
	const_reverse_iterator insert(const_reverse_iterator it, ElementType element);

	ElementType&back();
	void clear();
	bool empty()const;
	ElementType&front();
	void pop_back();
	void pop_front();
	void push_back(ElementType element);
	void push_front(ElementType element);
	void remove(ElementType const&element);
	void reverse();
	int size()const;
	void swap(list<ElementType>&object);
};

template<typename ElementType>
struct list<ElementType>::DataNode {
	typedef DataNode*NodePtr;
	ElementType data;
	NodePtr left, right;
	DataNode(ElementType init_element);
};

template<typename ElementType>
list<ElementType>::DataNode::DataNode(ElementType init_element) :data(init_element), left(NULL), right(NULL) {

}

//_ITERATOR_BEGIN

template<typename ElementType>
class list<ElementType>::iterator {
private:
	friend iterator list<ElementType>::erase(iterator it);
	friend iterator list<ElementType>::insert(iterator it, ElementType element);
	NodePtr PtrL;
public:
	iterator(NodePtr init_ptr);
	ElementType&operator*();
	iterator operator++();
	iterator operator++(int);
	iterator operator--();
	iterator operator--(int);
	bool operator==(iterator it)const;
	bool operator!= (iterator it)const;
	bool operator>(iterator it)const;
	bool operator>=(iterator it)const;
	bool operator<(iterator it)const;
	bool operator<=(iterator it)const;
};

template<typename ElementType>
list<ElementType>::iterator::iterator(list<ElementType>::NodePtr init_ptr) :PtrL(init_ptr) {

}

template<typename ElementType>
ElementType&list<ElementType>::iterator::operator*() {
	return PtrL->data;
}

template<typename ElementType>
typename list<ElementType>::iterator list<ElementType>::iterator::operator++() {
	PtrL = PtrL->right;
	return*this;
}

template<typename ElementType>
typename list<ElementType>::iterator list<ElementType>::iterator::operator++(int) {
	NodePtr temp = PtrL;
	PtrL = PtrL->right;
	return temp;
}

template<typename ElementType>
typename list<ElementType>::iterator list<ElementType>::iterator::operator--() {
	PtrL = PtrL->left;
	return*this;
}

template<typename ElementType>
typename list<ElementType>::iterator list<ElementType>::iterator::operator--(int) {
	NodePtr temp = PtrL;
	PtrL = PtrL->left;
	return temp;
}

template<typename ElementType>
bool list<ElementType>::iterator::operator==(list<ElementType>::iterator it)const {
	return PtrL == it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::iterator::operator!=(list<ElementType>::iterator it)const {
	return PtrL != it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::iterator::operator>(list<ElementType>::iterator it)const {
	return PtrL > it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::iterator::operator>=(list<ElementType>::iterator it)const {
	return PtrL >= it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::iterator::operator<(list<ElementType>::iterator it)const {
	return PtrL < it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::iterator::operator<=(list<ElementType>::iterator it)const {
	return PtrL <= it.PtrL ? true : false;
}

//_ITERATOR_END

//_CONST_ITERATOR_BEGIN

template<typename ElementType>
class list<ElementType>::const_iterator {
private:
	friend const_iterator list<ElementType>::erase(const_iterator it);
	friend const_iterator list<ElementType>::insert(const_iterator it, ElementType element);
	NodePtr PtrL;
public:
	const_iterator(NodePtr init_ptr);
	ElementType const&operator*();
	const_iterator operator++();
	const_iterator operator++(int);
	const_iterator operator--();
	const_iterator operator--(int);
	bool operator==(const_iterator it)const;
	bool operator!= (const_iterator it)const;
	bool operator>(const_iterator it)const;
	bool operator>=(const_iterator it)const;
	bool operator<(const_iterator it)const;
	bool operator<=(const_iterator it)const;
};

template<typename ElementType>
list<ElementType>::const_iterator::const_iterator(list<ElementType>::NodePtr init_ptr) :PtrL(init_ptr) {

}

template<typename ElementType>
ElementType const&list<ElementType>::const_iterator::operator*() {
	return PtrL->data;
}

template<typename ElementType>
typename list<ElementType>::const_iterator list<ElementType>::const_iterator::operator++() {
	PtrL = PtrL->right;
	return*this;
}

template<typename ElementType>
typename list<ElementType>::const_iterator list<ElementType>::const_iterator::operator++(int) {
	NodePtr temp = PtrL;
	PtrL = PtrL->right;
	return temp;
}

template<typename ElementType>
typename list<ElementType>::const_iterator list<ElementType>::const_iterator::operator--() {
	PtrL = PtrL->left;
	return*this;
}

template<typename ElementType>
typename list<ElementType>::const_iterator list<ElementType>::const_iterator::operator--(int) {
	NodePtr temp = PtrL;
	PtrL = PtrL->left;
	return temp;
}

template<typename ElementType>
bool list<ElementType>::const_iterator::operator==(list<ElementType>::const_iterator it)const {
	return PtrL == it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::const_iterator::operator!=(list<ElementType>::const_iterator it)const {
	return PtrL != it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::const_iterator::operator>(list<ElementType>::const_iterator it)const {
	return PtrL > it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::const_iterator::operator>=(list<ElementType>::const_iterator it)const {
	return PtrL >= it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::const_iterator::operator<(list<ElementType>::const_iterator it)const {
	return PtrL < it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::const_iterator::operator<=(list<ElementType>::const_iterator it)const {
	return PtrL <= it.PtrL ? true : false;
}

//_CONST_ITERATOR_END

//_REVERSE_ITERATOR_BEGIN

template<typename ElementType>
class list<ElementType>::reverse_iterator {
private:
	friend reverse_iterator list<ElementType>::erase(reverse_iterator it);
	friend reverse_iterator list<ElementType>::insert(reverse_iterator it, ElementType element);
	NodePtr PtrL;
public:
	reverse_iterator(NodePtr init_ptr);
	ElementType&operator*();
	reverse_iterator operator++();
	reverse_iterator operator++(int);
	reverse_iterator operator--();
	reverse_iterator operator--(int);
	bool operator==(reverse_iterator it)const;
	bool operator!= (reverse_iterator it)const;
	bool operator>(reverse_iterator it)const;
	bool operator>=(reverse_iterator it)const;
	bool operator<(reverse_iterator it)const;
	bool operator<=(reverse_iterator it)const;
};

template<typename ElementType>
list<ElementType>::reverse_iterator::reverse_iterator(list<ElementType>::NodePtr init_ptr) :PtrL(init_ptr) {

}

template<typename ElementType>
ElementType&list<ElementType>::reverse_iterator::operator*() {
	return PtrL->data;
}

template<typename ElementType>
typename list<ElementType>::reverse_iterator list<ElementType>::reverse_iterator::operator++() {
	PtrL = PtrL->left;
	return*this;
}

template<typename ElementType>
typename list<ElementType>::reverse_iterator list<ElementType>::reverse_iterator::operator++(int) {
	NodePtr temp = PtrL;
	PtrL = PtrL->left;
	return temp;
}

template<typename ElementType>
typename list<ElementType>::reverse_iterator list<ElementType>::reverse_iterator::operator--() {
	PtrL = PtrL->right;
	return*this;
}

template<typename ElementType>
typename list<ElementType>::reverse_iterator list<ElementType>::reverse_iterator::operator--(int) {
	NodePtr temp = PtrL;
	PtrL = PtrL->right;
	return temp;
}

template<typename ElementType>
bool list<ElementType>::reverse_iterator::operator==(list<ElementType>::reverse_iterator it)const {
	return PtrL == it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::reverse_iterator::operator!=(list<ElementType>::reverse_iterator it)const {
	return PtrL != it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::reverse_iterator::operator>(list<ElementType>::reverse_iterator it)const {
	return PtrL > it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::reverse_iterator::operator>=(list<ElementType>::reverse_iterator it)const {
	return PtrL >= it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::reverse_iterator::operator<(list<ElementType>::reverse_iterator it)const {
	return PtrL < it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::reverse_iterator::operator<=(list<ElementType>::reverse_iterator it)const {
	return PtrL <= it.PtrL ? true : false;
}

//_REVERSE_ITERATOR_END

//_CONST_REVERSE_ITERATOR_BEGIN

template<typename ElementType>
class list<ElementType>::const_reverse_iterator {
private:
	friend const_reverse_iterator list<ElementType>::erase(const_reverse_iterator it);
	friend const_reverse_iterator list<ElementType>::insert(const_reverse_iterator it, ElementType element);
	NodePtr PtrL;
public:
	const_reverse_iterator(NodePtr init_ptr);
	ElementType const&operator*();
	const_reverse_iterator operator++();
	const_reverse_iterator operator++(int);
	const_reverse_iterator operator--();
	const_reverse_iterator operator--(int);
	bool operator==(const_reverse_iterator it)const;
	bool operator!= (const_reverse_iterator it)const;
	bool operator>(const_reverse_iterator it)const;
	bool operator>=(const_reverse_iterator it)const;
	bool operator<(const_reverse_iterator it)const;
	bool operator<=(const_reverse_iterator it)const;
};

template<typename ElementType>
list<ElementType>::const_reverse_iterator::const_reverse_iterator(list<ElementType>::NodePtr init_ptr) :PtrL(init_ptr) {

}

template<typename ElementType>
ElementType const&list<ElementType>::const_reverse_iterator::operator*() {
	return PtrL->data;
}

template<typename ElementType>
typename list<ElementType>::const_reverse_iterator list<ElementType>::const_reverse_iterator::operator++() {
	PtrL = PtrL->left;
	return*this;
}

template<typename ElementType>
typename list<ElementType>::const_reverse_iterator list<ElementType>::const_reverse_iterator::operator++(int) {
	NodePtr temp = PtrL;
	PtrL = PtrL->left;
	return temp;
}

template<typename ElementType>
typename list<ElementType>::const_reverse_iterator list<ElementType>::const_reverse_iterator::operator--() {
	PtrL = PtrL->right;
	return*this;
}

template<typename ElementType>
typename list<ElementType>::const_reverse_iterator list<ElementType>::const_reverse_iterator::operator--(int) {
	NodePtr temp = PtrL;
	PtrL = PtrL->right;
	return temp;
}

template<typename ElementType>
bool list<ElementType>::const_reverse_iterator::operator==(list<ElementType>::const_reverse_iterator it)const {
	return PtrL == it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::const_reverse_iterator::operator!=(list<ElementType>::const_reverse_iterator it)const {
	return PtrL != it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::const_reverse_iterator::operator>(list<ElementType>::const_reverse_iterator it)const {
	return PtrL > it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::const_reverse_iterator::operator>=(list<ElementType>::const_reverse_iterator it)const {
	return PtrL >= it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::const_reverse_iterator::operator<(list<ElementType>::const_reverse_iterator it)const {
	return PtrL < it.PtrL ? true : false;
}

template<typename ElementType>
bool list<ElementType>::const_reverse_iterator::operator<=(list<ElementType>::const_reverse_iterator it)const {
	return PtrL <= it.PtrL ? true : false;
}

//_CONST_REVERSE_ITERATOR_END

template<typename ElementType>
list<ElementType>::list() :head(NULL), tail(NULL), _size(0) {

}

template<typename ElementType>
list<ElementType>::~list() {
	NodePtr PtrL, it;
	for (it = head; it != tail;) {
		PtrL = it->right;
		delete it;
		it = PtrL;
	}
	delete tail;
}

template<typename ElementType>
typename list<ElementType>::iterator list<ElementType>::begin()const {
	return iterator(head);
}

template<typename ElementType>
typename list<ElementType>::iterator list<ElementType>::end()const {
	if (NULL == tail)return iterator(NULL);
	return iterator(tail->right);
}

template<typename ElementType>
typename list<ElementType>::const_iterator list<ElementType>::cbegin()const {
	return const_iterator(head);
}

template<typename ElementType>
typename list<ElementType>::const_iterator list<ElementType>::cend()const {
	if (NULL == tail)return const_iterator(NULL);
	return const_iterator(tail->right);
}

template<typename ElementType>
typename list<ElementType>::reverse_iterator list<ElementType>::rbegin()const {
	return reverse_iterator(tail);
}

template<typename ElementType>
typename list<ElementType>::reverse_iterator list<ElementType>::rend()const {
	if (NULL == head)return reverse_iterator(NULL);
	return reverse_iterator(head->left);
}

template<typename ElementType>
typename list<ElementType>::const_reverse_iterator list<ElementType>::crbegin()const {
	return const_reverse_iterator(tail);
}

template<typename ElementType>
typename list<ElementType>::const_reverse_iterator list<ElementType>::crend()const {
	if (NULL == head)return const_reverse_iterator(NULL);
	return const_reverse_iterator(head->left);
}

//_ERASE_BEGIN

template<typename ElementType>
typename list<ElementType>::iterator list<ElementType>::erase(list<ElementType>::iterator it) {
	if (!_size)return iterator(NULL);
	NodePtr temp;
	_size--;
	if (begin() == it) {
		temp = head->right;
		temp->left = NULL;
		delete head;
		head = temp;
		return iterator(head);
	}
	if (tail == it.PtrL) {
		temp = tail->left;
		temp->right = NULL;
		delete tail;
		tail = temp;
		return iterator(NULL);
	}
	temp = it.PtrL->right;
	temp->left = it.PtrL->left;
	it.PtrL->left->right = temp;
	delete it.PtrL;
	return iterator(temp);
}

template<typename ElementType>
typename list<ElementType>::const_iterator list<ElementType>::erase(list<ElementType>::const_iterator it) {
	if (!_size)return const_iterator(NULL);
	NodePtr temp;
	_size--;
	if (cbegin() == it) {
		temp = head->right;
		temp->left = NULL;
		delete head;
		head = temp;
		return const_iterator(head);
	}
	if (tail == it.PtrL) {
		temp = tail->left;
		temp->right = NULL;
		delete tail;
		tail = temp;
		return const_iterator(tail);
	}
	temp = it.PtrL->right;
	temp->left = it.PtrL->left;
	it.PtrL->left->right = temp;
	delete it.PtrL;
	return const_iterator(temp);
}

template<typename ElementType>
typename list<ElementType>::reverse_iterator list<ElementType>::erase(list<ElementType>::reverse_iterator it) {
	if (!_size)return reverse_iterator(NULL);
	NodePtr temp;
	_size--;
	if (rbegin() == it) {
		temp = tail->left;
		temp->right = NULL;
		delete tail;
		tail = temp;
		return reverse_iterator(tail);
	}
	if (head == it.PtrL) {
		temp = head->right;
		temp->left = NULL;
		delete head;
		head = temp;
		return reverse_iterator(NULL);
	}
	temp = it.PtrL->left;
	temp->right = it.PtrL->right;
	it.PtrL->right->left = temp;
	delete it.PtrL;
	return reverse_iterator(temp);
}

template<typename ElementType>
typename list<ElementType>::const_reverse_iterator list<ElementType>::erase(list<ElementType>::const_reverse_iterator it) {
	if (!_size)return const_reverse_iterator(NULL);
	NodePtr temp;
	_size--;
	if (crbegin() == it) {
		temp = tail->left;
		temp->right = NULL;
		delete tail;
		tail = temp;
		return const_reverse_iterator(tail);
	}
	if (head == it.PtrL) {
		temp = head->right;
		temp->left = NULL;
		delete head;
		head = temp;
		return const_reverse_iterator(NULL);
	}
	temp = it.PtrL->left;
	temp->right = it.PtrL->right;
	it.PtrL->right->left = temp;
	delete it.PtrL;
	return const_reverse_iterator(temp);
}

//_ERASE_END

//_INSERT_BEGIN

template<typename ElementType>
typename list<ElementType>::iterator list<ElementType>::insert(typename list<ElementType>::iterator it, ElementType element) {
	NodePtr create = new DataNode(element);
	_size++;
	if (begin() == it) {
		create->right = head;
		head->left = create;
		head = create;
	}
	else if (end() == it) {
		create->left = tail;
		tail->right = create;
		tail = create;
	}
	else {
		create->left = it.PtrL->left;
		create->right = it.PtrL;
		it.PtrL->left->right = create;
		it.PtrL->left = create;
	}
	return iterator(create);
}

template<typename ElementType>
typename list<ElementType>::const_iterator list<ElementType>::insert(typename list<ElementType>::const_iterator it, ElementType element) {
	NodePtr create = new DataNode(element);
	_size++;
	if (cbegin() == it) {
		create->right = head;
		head->left = create;
		head = create;
	}
	else if (cend() == it) {
		create->left = tail;
		tail->right = create;
		tail = create;
	}
	else {
		create->left = it.PtrL->left;
		create->right = it.PtrL;
		it.PtrL->left->right = create;
		it.PtrL->left = create;
	}
	return const_iterator(create);
}

template<typename ElementType>
typename list<ElementType>::reverse_iterator list<ElementType>::insert(typename list<ElementType>::reverse_iterator it, ElementType element) {
	NodePtr create = new DataNode(element);
	_size++;
	if (rbegin() == it) {
		create->left = tail;
		tail->right = create;
		tail = create;
	}
	else if (rend() == it) {
		create->right = head;
		head->left = create;
		head = create;
	}
	else {
		create->right = it.PtrL->right;
		create->left = it.PtrL;
		it.PtrL->right->left = create;
		it.PtrL->right = create;
	}
	return reverse_iterator(create);
}

template<typename ElementType>
typename list<ElementType>::const_reverse_iterator list<ElementType>::insert(typename list<ElementType>::const_reverse_iterator it, ElementType element) {
	NodePtr create = new DataNode(element);
	_size++;
	if (crbegin() == it) {
		create->left = tail;
		tail->right = create;
		tail = create;
	}
	else if (crend() == it) {
		create->right = head;
		head->left = create;
		head = create;
	}
	else {
		create->right = it.PtrL->right;
		create->left = it.PtrL;
		it.PtrL->right->left = create;
		it.PtrL->right = create;
	}
	return const_reverse_iterator(create);
}

//_INSERT_END

template<typename ElementType>
ElementType&list<ElementType>::back() {
	return tail->data;
}

template<typename ElementType>
void list<ElementType>::clear() {
	NodePtr PtrL, it;
	for (it = head; it != tail;) {
		PtrL = it->right;
		delete it;
		it = PtrL;
	}
	delete tail;
	head = tail = NULL;
	_size = 0;
}

template<typename ElementType>
bool list<ElementType>::empty()const {
	return _size ? false : true;
}

template<typename ElementType>
ElementType&list<ElementType>::front() {
	return head->data;
}

template<typename ElementType>
void list<ElementType>::pop_back() {
	if (!_size)return;
	_size--;
	if (head == tail) {
		delete head;
		head = tail = NULL;
	}
	else {
		tail = tail->left;
		delete tail->right;
		tail->right = NULL;
	}
}

template<typename ElementType>
void list<ElementType>::pop_front() {
	if (!_size)return;
	_size--;
	if (head == tail) {
		delete head;
		head = tail = NULL;
	}
	else {
		head = head->right;
		delete head->left;
		head->left = NULL;
	}
}

template<typename ElementType>
void list<ElementType>::push_back(ElementType element) {
	if (!_size++) {
		head = new DataNode(element);
		tail = head;
	}
	else {
		NodePtr PtrL = tail;
		tail = tail->right = new DataNode(element);
		tail->left = PtrL;
	}
}

template<typename ElementType>
void list<ElementType>::push_front(ElementType element) {
	if (!_size++) {
		head = new DataNode(element);
		tail = head;
	}
	else {
		NodePtr PtrL = head;
		head = head->left = new DataNode(element);
		head->right = PtrL;
	}
}

template<typename ElementType>
void list<ElementType>::remove(ElementType const&element) {
	for (auto it = begin(); it != end();)
		if (element == *it)it = erase(it);
		else it++;
}

template<typename ElementType>
void list<ElementType>::reverse() {
	if (!_size || 1 == _size)return;
	iterator left_ptr(head), right_ptr(tail);
	ElementType temp;
	if (_size | 0)
		for (int count = 0; count != _size / 2; count++) {
			temp = *left_ptr;
			*left_ptr = *right_ptr;
			*right_ptr = temp;
			left_ptr++;
			right_ptr--;
		}
	else for (; left_ptr != right_ptr; left_ptr++, right_ptr--) {
		temp = *left_ptr;
		*left_ptr = *right_ptr;
		*right_ptr = temp;
	}
}

template<typename ElementType>
int list<ElementType>::size()const {
	return _size;
}

template<typename ElementType>
void list<ElementType>::swap(list<ElementType>&object) {
	NodePtr temp = head;
	head = object.head;
	object.head = temp;
	temp = tail;
	tail = object.tail;
	object.tail = temp;
}

_OC_END

#endif