双向链表List---类模板实现
在前面我们用C++中的类来实现了双向链表，C++实现双向链表今天我们用模板类来实现各种可能出现的类型的带头双向链表（容器List）。
该链表不仅是带头的双向链表，而且头节点与尾结点构成了循环链表
代码如下：
/*
#pragma once
#include
#include
using namespace std;
template<class T>
struct ListNode
{
ListNode(const T& data = T())
: _prev(0)
, _next(0)
, _data(data)
{}
ListNode<T>* _prev;
ListNode<T>* _next;
T _data;
};
template<class T, class Ref, class Ptr>
class __ListIterator__
{
typedef __ListIterator__<T, T&, T*> Iterator;
typedef __ListIterator__<T, const T&, const T*> ConstIterator;
typedef __ListIterator__<T, Ref, Ptr> Self;
typedef ListNode<T>* LinkType;
typedef Ref Reference;
typedef Ptr Pointer;
public:
__ListIterator__(LinkType x = 0)
:_node(x)
{}
__ListIterator__(const Iterator& x)
{
_node = x._node;
}
bool operator==(const Iterator& x)
{
return _node == x._node;
}
bool operator!=(const Iterator& x)
{
return _node != x._node;
}
Reference operator*()
{
return (*_node)._data;
}
Pointer operator->()
{
return &(operator*());
}
Self& operator++()
{
_node = _node->_next;
return *this;
}
Self operator++(int)
{
Self pTemp(*this);
_node = _node->_next;
return pTemp;
}
Self& operator--()
{
_node = _node->_prev;
return *this;
}
Self operator--(int)
{
Self pTemp(*this);
_node = _node->_prev;
return pTemp;
}
public:
LinkType _node;
};
template<class T>
class List
{
public:
typedef ListNode<T> Node;
typedef T ValueType;
typedef ValueType& Reference;
typedef const ValueType& ConstReference;
typedef ValueType* Pointer;
typedef const ValueType* ConstPointer;
typedef Node* LinkType;
typedef size_t SizeType;
typedef __ListIterator__<T, T&, T*> Iterator;
typedef __ListIterator__<T, const T&, const T*> ConstIterator;
public:
//构造函数
List()
{
EmptyInit();
}
List(SizeType n, const T& data)
{
EmptyInit();
for(size_t idx=0; idx<n; ++idx)
{
PushBack(data);
}
}
//拷贝构造函数
List(const List<T>& l)
{
EmptyInit();
Iterator it = l._node->_next;
for(SizeType idx=0; idx<l.Size(); ++idx)
{
PushBack(it._node->_data);
it++;
}
}
//析构函数
~List()
{
/*Iterator it = End();
--it;
while(it!=_node)
{
delete it._node;
--it;
}*/
Clear();
delete _node;
}
//赋值运算符重载
//List<T>& operator=(const List<T>& l)
//{
// List<T> pTempList(l);
// if(this != &l)
// {
// Iterator it = --End();
// while(it != _node)
// {
// it = Erase(it);
// }
// //Clear();//错误
// delete _node;
// _node = pTempList._node;
// }
// return *this;
//}
//
Iterator Begin()
{
return _node->_next;
}
ConstIterator Begin()const
{
return _node->_next;
}
Iterator End()
{
return _node;
}
ConstIterator End()const
{
return _node;
}
bool Empty()
{
return _node==_node->_next;
}
SizeType Size()const
{
Iterator it = _node->_next;
SizeType count = 0;
while(it != _node)
{
count = count+1;
it++;
}
return count;
}
SizeType MaxSize()const
{
return SizeType(-1);
}
Reference Front()
{
return *(Begin());
}
ConstReference Front()const
{
return *(Begin());
}
Reference Back()
{
return *(--End());
}
ConstReference Back()const
{
return *(--End());
}
Iterator Insert(Iterator pos, const T& x = T())
{
LinkType temp = new Node(x);
temp->_next = pos._node;
temp->_prev = pos._node->_prev;
pos._node->_prev->_next = temp;
pos._node->_prev = temp;
return temp;
}
void PushFront(const T& x)
{
Insert(Begin(),x);
}
void PushBack(const T& x)
{
Iterator it = End();
Insert(it,x);
}
//任意位置删除
Iterator Erase(Iterator pos)
{
Iterator pRemNode = pos._node->_next;
pos._node->_prev->_next= pos._node->_next;
pos._node->_next->_prev = pos._node->_prev;
pos._node->_next = pos._node->_prev = NULL;
delete pos ._node;
return pRemNode;
}
void PopFront()
{
Erase(Begin());
}
void PopBack()
{
Erase(--End());
}
void ReSize(SizeType n, const T& data)
{
if(Size() >= n)
{
SizeType size1 = Size()-n;
while(size1--)
{
PopBack();
}
}
else
{
SizeType size2 = n-Size();
while(size2--)
{
PushBack(data);
}
}
}
void Assign(SizeType n, const T& data)
{
Iterator pTemp = _node->_next;
if(Size()>=n)
{
for(size_t idx=0;idx<n; ++idx)
{
pTemp._node->_data = data;
++pTemp;
}
for(size_t idx = 0; idx<Size()-n; ++idx)
{
PopBack();
}
}
else
{
pTemp = _node->_next;
size_t size = Size();
for(size_t idx=0; idx<size; ++idx)
{
pTemp._node->_data = data;
++pTemp;
}
for(size_t idx = 0;idx<n-size; ++idx)
{
PushBack(data);
}
}
}
void Clear()
{
Iterator it = --End();
while(it != _node)
{
it = Erase(it);
}
_node->_next = _node;
_node->_prev = _node;
}
private:
void EmptyInit()
{
_node = new Node;
_node->_data = 0;
_node->_next = _node ;
_node->_prev = _node;
}
protected:
LinkType _node;
};