//list.h双向链表类
#include<iostream>
#include<string>
using namespace std;
template<typename T>
class list
{
protected:
//节点结构体
struct Node
{
T item;
Node* next;
Node* prev;
};
public:
//构造函数,链表初始化
list()
{
length=0;
head=NULL;
tail=NULL;
}
//返回链表节点的个数
long size() const
{
return length;
}
//在链表的前端插入
void push_front(const T &newitem)
{
Node *newHead= new Node;
newHead->item=newitem;
if(length==0)
{
head=newHead;
tail=newHead;
}
else if(length>=1)
{
newHead->next=head;
head->prev=newHead;
head=newHead;
}
length++;
}
//在链表前端删除节点
void pop_front()
{
Node *oldHead=new Node;
oldHead=head;
head=head->next;
delete oldHead;
length--;
}
//在链表的后端插入
void push_back(const T &newitem)
{
Node *newTail=new Node;
newTail->item=newitem;
if(length==0)
{
head=newTail;
tail=newTail;
}
else if(length>=1)
{
newTail->prev=tail;
tail->next=newTail;
tail=newTail;
}
length++;
}
//在链表的尾部删除
void pop_back()
{
Node *oldTail=new Node;
oldTail=tail;
tail=tail->prev;
delete oldTail;
length--;
}
//list类的析构函数
~list()
{
while(length!=0)
pop_front();
}
//迭代器类
class Iterator
{
friend list;
public: Iterator(){}//迭代器默认构造函数
//重载判等操作符
bool operator ==(Iterator & newIterator)
{
return(nodePtr==newIterator.nodePtr);
}
//重载判不等操作符
bool operator !=(Iterator & newIterator)
{
return(nodePtr!=newIterator.nodePtr);
}
//重载后自增操作符
Iterator operator ++(int)
{
Iterator temp=*this;
nodePtr=(*nodePtr).next;
return temp;
}
//重载后自减运算符
Iterator operator --(int)
{
Iterator temp=*this;
nodePtr=(*nodePtr).prev;
return temp;
}
//重载解引用操作符
T &operator *()
{
return( nodePtr->item);
}
protected:
//迭代器带一个形参的构造函数
Iterator(Node *newPtr)
{
nodePtr=newPtr;
}
private :
//迭代器的唯一数据成员
Node *nodePtr;
};
//返回指向首个节点的迭代器
Iterator begin()
{
return Iterator(head);
}
//返回指向最后一个节点的迭代器
Iterator end()
{
return Iterator(tail->next);
}
//返回rbegin
Iterator rbegin()
{
return Iterator(tail);
}
//返回 rend
Iterator rend()
{
return Iterator(head->prev);
}
//list链表类的数据成员
private:
long length;
Node* head;
Node* tail;
};