List数据结构的实现

这几天在学习数据结构(C++描述)的知识，为了把基础打的牢固一些，想想把一种数据结构自己动手写代码实现以下，感觉是个不错的方法。那样就不会只停留在会用的程度。首先整理一下要实现的山寨list要提供的接口。

push_back() 末端插入元素

back() 返回末端元素的值

push_front() 顶端插入元素

front() 返回顶端元素的值

find() 查找特定元素的地址

insert() 特定的位置插入元素

size() 返回list当中元素的个数

begin() 返回一个游标，指向顶端元素

end() 返回一个游标，指向末端元素

实现山寨list，底层的数据结构肯定选双向链表，在任何位置插入元素的复杂度都为o(1)，双向链表是由一个个节点链接起来的，节点包括三个成员：指向后继节点的指针、指向前驱节点的指针、当前节点的节点值。先实现这个类：

template <typename T>
class dnode{
public:
T nodeValue;//节点值
dnode<T> *next;//后继节点
dnode<T> *prev;//前驱节点
dnode(const T& value=T()){
nodeValue=value;
next=NULL;
prev=NULL;
};//构造函数，初始化节点值、前驱和后继节点
};

然后将一个个节点串接起来就形成了双向链表，将双向链表的首位相接，就得到一个list，就像用一个个珠子串起来串成项链一样。实现miniList这个类：

#include "dnode.h"
#include <string>
using namespace std;
template <typename T>
class miniList{
public:
miniList();/*三个版本的构造函数
/第一个生成一个空list，第二个初始化list为n个item值的list
第三个用[first,last]初始化list*/
miniList(int n,const T& item=T());
miniList(T *first,T *last);
~miniList();//析构函数
/*游标的声明*/
class iterator{
public:
iterator();//构造函数，生成一个空游标
iterator(dnode<T> *p);//构造函数，将dnode类型的指针转换为游标
/*重载"=="和"!="运算符，比较两个游标所指的值*/
bool operator ==(const iterator& rhs) const;
bool operator !=(const iterator& rhs) const;
/*重载"*"运算符，返回游标所指的值*/
T& operator *();
/*重载"++"和"--"运算符，因为这两个运算符有前缀和后缀的形式，所以后缀运算符多加一个
int参数，好让编译器判断用户使用的是哪种形式。游标的本质其实还是指针，所以++或者--
只是让私有成员node成为自身的后继或者前驱*/
iterator& operator ++(){
node=node->next;
return *this;
};
iterator& operator ++(int){
iterator temp=*this;
node=node->next;
return temp;
};
iterator& operator --(){
node=node->prev;
return *this;
};
iterator& operator --(int){
iterator temp=*this;
node=node->prev;
return temp;
};
private:
//游标的本质还是指针，指针的类型就是实现list的基石--dnode
dnode<T> *node;
};
void push_back(const T& item);//在list末端插入值
T& back();//返回list末端的值
void push_front(const T& item);//在list顶端插入值
T& front();//返回list顶端的值
/*在固定的位置插入值，返回新的新节点的地址，因为dnode指针是对外不可见的，所以要和find函数搭配使用*/
dnode<T>* insert(const T& item,dnode<T> *curr);
dnode<T>* find(const T& item);//查找一个元素的位置，返回这个元素的指针
int size();//返回当前list的元素个数
typename miniList<T>::iterator begin();//返回一个游标对象，指向list的顶端值
typename miniList<T>::iterator end();//返回一个游标对象，指向list的末端值
private:
dnode<T> *header;//头结点
int listSize;//元素个数
};
template <typename T>//构造函数，生成一个空list，元素个数为0
miniList<T>::miniList(){
header=new dnode<T>;
listSize=0;
}
template <typename T>//构造函数，生个n个item元素的list
miniList<T>::miniList(int n,const T& item=T()){
header=new dnode<T>(item);
dnode<T> *temp;//存储n个item值的动态节点
dnode<T> *curr;//当前节点
curr=header;
unsigned int i;
for(i=0;i<n;i++){
temp=new dnode<T>(item);//生成一个节点
curr->next=temp;//当前节点的后继节点就是这个新生成的节点
temp->prev=curr;//新节点的前驱节点为当前节点
curr=temp;//更新当前节点，继续生成下一个节点
}
curr->next=header;//结束之后将当前节点的后继节点更新为头结点
header->prev=curr;//头结点的前驱节点为当前这个节点，这样整个list就串起来
listSize=n;//元素个数更新为n
}
template <typename T>
miniList<T>::miniList(T *first,T *last){
/*先计算出first到last这段地址的元素数，其他的与上面类似，
区别只是生成新节点时的节点值为当前地址中保存的值*/
int n=last-first;
header=new dnode<T>;
dnode<T> *temp;
dnode<T> *curr;
curr=header;
unsigned int i;
for(i=0;i<n;i++){
temp=new dnode<T>(*first);
curr->next=temp;
temp->prev=curr;
curr=temp;
first++;
}
curr->next=header;
header->prev=curr;
listSize=n;
}
template <typename T>//析构函数，遍历整个list，逐个释放内存
miniList<T>::~miniList(){
dnode<T> *curr;
curr=header->next;
while(curr!=header){
delete curr;
curr=curr->next;
}
delete header;
}
template <typename T>//在list的末端插入值
void miniList<T>::push_back(const T& item){
dnode<T> *temp,*curr;
temp=new dnode<T>(item);
if(listSize==0){//表示当前list中只有一个header
header->next=temp;
temp->next=header;
header->prev=temp;
temp->prev=header;
}else if(listSize>0){
//元素数不为0，在末端插入值其实就是在header前面插入值，因为list是串起来的环，先找到header的前驱
curr=header->prev;
//打开header的前驱和header，在中间插入新生成的temp
curr->next=temp;
temp->next=header;
header->prev=temp;
temp->prev=curr;
}
listSize++;
}
template <typename T>
T& miniList<T>::back(){
if(listSize>0)//元素个数不为0，返回末端元素的值，其实就是header前驱节点的值
return header->prev->nodeValue;
}
template <typename T>//在顶端和在末端插入元素的方法类似，区别只是在顶端插入值时，插入的位置为header和header后继节点的中间。
void miniList<T>::push_front(const T& item){
dnode<T> *curr,*temp;
temp=new dnode<T>(item);
if(listSize==0){
header->next=temp;
temp->prev=header;
temp->next=header;
header->prev=temp;
}else if(listSize>0){
curr=header->next;
header->next=temp;
temp->next=curr;
temp->prev=header;
curr->prev=temp;
}
listSize++;
}
template <typename T>
T& miniList<T>::front(){
if(listSize>0)//元素个数不为0，返回顶端元素，其实就是header后继节点的节点值
return header->next->nodeValue;
}
template <typename T>
int miniList<T>::size(){
return listSize;//返回当前元素的个数
}
template <typename T>//返回一个游标，指向顶端元素，
typename miniList<T>::iterator miniList<T>::begin(){
return iterator(header->next);//调用iterator的构造函数，将dnode类型的指针转换为游标
}
template <typename T>
typename miniList<T>::iterator miniList<T>::end(){
return iterator(header);//与begin函数类似，区别是end返回的游标指向list的header，而不是一个具体的元素
}
template <typename T>//在固定的位置插入一个值
dnode<T>* miniList<T>::insert(const T& item,dnode<T> *curr){
dnode<T> *tempNode,*tempPrev;
tempNode=new dnode<T>(item);//新生成一个节点
tempPrev=curr->prev;//找到插入位置的前驱节点

tempPrev->next=tempNode;//插入这个新节点
tempNode->next=curr;
curr->prev=tempNode;
tempNode->prev=tempPrev;
listSize++;
return tempNode;
}
template <typename T>//查找一个元素，返回它的地址，不在list当中则返回NULL
dnode<T>* miniList<T>::find(const T& item){
dnode<T> *temp=header->next;
//查找元素，直到找到该元素或者遍历完整个list
while(temp->nodeValue!=item&&temp!=header){
temp=temp->next;
}
if(temp!=header)//找到的该元素，返回它的地址
return temp;
return NULL;//遍历完整个list，说明不在list当中，返回NULL
}
template <typename T>//游标的两个构造函数，第一个生成一个空游标，第二个将dnode类型的指针转换为游标
miniList<T>::iterator::iterator(){
node=NULL;
}
template <typename T>
miniList<T>::iterator::iterator(dnode<T> *p){
node=p;
}
template <typename T>//重载的运算符，比较两个游标所指元素的元素值
bool miniList<T>::iterator::operator==(const iterator& rhs)const{
return node->nodeValue==rhs.node->nodeValue;
}
template <typename T>
bool miniList<T>::iterator::operator!=(const iterator& rhs)const{
return node->nodeValue!=rhs.node->nodeValue;
}
template <typename T>//重载的"*"运算符，返回游标所指元素的值
T& miniList<T>::iterator::operator*(){
return node->nodeValue;
}

测试一下能不能正常的工作：

void main(){
unsigned int i;
int a[]={1,6,2,5,6,7};
miniList<int> list1(a,a+6);
miniList<int>::iterator it;
dnode<int> *temp;
temp=list1.find(2);
list1.insert(3,temp);
list1.push_back(9);
it=list1.begin();
while(it!=list1.end()){
cout<<*it<<" ";
it++;
}
while(1);
}

先用数组初始化一个list，生成一个空游标，并用list的end函数初始化，找到2的地址，在2前面插入3，在末端插入9，最后输出list的全部元素，测试结果：



按照预定的方式运行了，由于想让代码看起来简洁，没有进行异常的捕捉，也假设测试输入都是正确的。