STL中双向链表的简单实现

整体构架

将list链表的实现分为层结构：

第一层：用于保存元素数值及前后元素地址的结构体，定名为Node

struct Node
{
Object data;   //保存数值
Node *prev;    //保存前导地址；
Node *next;    //保存后继地址；
};

 

第二层：定义用于定位的迭代器。迭代器保存Node类型的地址，从未为上层函数提供确定元素位置的功能，实际上就是一个Node结构体的指针。

//定义套嵌的迭代器类
class iteractor
{
public:
//重载迭代器的构造函数
iteractor(Node *p):current(p){};

//返回指向的数据值；
Object retieve() const
{
return current->data;
}

//重载自加运算符(前缀的自加运算
iteractor  operator++ ()
{
Node *Oldcurrent=current->next;
current=Oldcurrent;     //自加操作后迭代器指向下一个元素
return iteractor(current);
}

//重载后缀的自加操作符
/*(iteractor & operator++(int)
{

}*/

//重载“==”预算符号
bool operator ==(iteractor &itr)
{
return current==itr.current;
}

//重载“！=”预算符号
bool operator !=(iteractor &itr) const
{
return current!=itr.current;
}

public:
Node *current;     //迭代器为Node类型的地址

};

 

public:
Node *current;     //迭代器为Node类型的地址

};

 

 

第三层：基础的功能函数，包括访问函数

判断是否为空的Empty（）；

template<class Object>
bool List<Object>::Empty()
{
if(theSize==0)
return 1;
else
return 0;
}

 

返回链表中的元素个数的theSize（）

template<class Object>
int List<Object>::Size()
{
return theSize;
}

返回头元素的地址的begin（）；

//返回链表头部的地址迭代器
iteractor begin()
{
return iteractor(head->next);
}

 

返回尾元素地址的end（）；

/返回链表尾部的地址迭代器
iteractor end()
{
return iteractor(tail);
}

 

以及操作函数：

插入元素insert（）

//在指定位置插入相应的数值
iteractor insert(iteractor itr,Object x)      //
{
Node *p=new Node;          //为新元素创建分配一块内存
p->data=x;                 //新元素的数值赋值
p->prev=itr.current->prev; //新元素前导地址为1；
p->next=itr.current;       //新元素后继地址
itr.current->prev->next=p; //
itr.current->prev=p;       //
theSize++;
return iteractor(p);

}

 

删除元素erase（）

//在指定的位置删除元素
void erase(iteractor itr)       //
{
itr.current->next->prev=itr.current->prev;
itr.current->prev->next=itr.current->next;
}

以上这些第三层的函数，都是为第四层的对表的操作的高级函数进行具体执行工作的；

 

第四层 这一层主要执行对表的操作

 

在表头插入元素push_front

//在头部插入元素
void push_front(Object x)
{
insert(begin(),x);
}

 

在表头删除元素pop_fronr

//在头部弹出元素
void pop_front()
{
erase(begin());
}

 

在表的末尾插入元素push_end

//在尾部插入元素
void push_end(Object x)
{
insert(end(),x);
}

 

在表尾弹出元素pop_end

//在尾部弹出元素
void pop_end()
{
erase(iteractor(end().current->prev));
}

 

注意事项

1、由于链表只是一个保存不同数据类型数据的一种容器形式，因此保存在list中的数据可能是各种类型的数据，为了适应各种的数据类型，将list类设置为类模板

template<typename Object>
class List
{

 

2、由于list是一个模板类，因此list类的成员函数最好在类内部进行声明和定义，因为若在外部定义其定义表述极其的繁琐，如下面empty这个函数

template<class Object>
bool List<Object>::Empty()
{
if(theSize==0)
return 1;
else
return 0;
}

 

3、迭代器（iterator)是一个套嵌在list类中的新的类型，需要在list类中进行定义。其本质是保存Node结构体的地址，其主体是其数据成员current。

 

public:
Node *current;     //迭代器为Node类型的地址

 

4、list链表的数据成员包括了元素个数（theSize）、头元素（head)、尾元素（tail）。其中头元素和尾元素只是作为标志位，用于定位链表的开头和结尾的位置，不计入链表的元素个数，这从list的构造函数中就能够看出

List()
{
theSize=0;
head=new Node;
tail=new Node;
head->next=tail;
tail->prev=head;
tail->next=NULL;
}

 

5、在函数begin返回函数头是，迭代器存的并不是head的地址，而是head后面的元素的地址

 

 


 

而end函数返回的指针则是指向tail元素自己