【STL】模拟STL中的List轮

直接进入正题：

先来看看list轮是个什么东西



每一个节点都一个prev指针和一个next指针，除了第一个节点没有内容，但它的prev指针指向最后一个节点，最后一个元素的next指针指向第一个元节点

首先看看STL库中的list 接口：（本文全部用类模版实现）



要实现这么多的函数，这里只是实现基本的函数

定义节点结构

template<class T>
struct _ListNode
{
_ListNode<T>* _prev;
_ListNode<T>* _next;
T _data;
_ListNode(const T& x)
:_prev(NULL)
,_next(NULL)
,_data(x)
{
}
};

模拟迭代器功能

template<class T,class Ref,class Ptr>
struct _ListIterator
{
typedef _ListNode<T> Node;
typedef _ListIterator<T,Ref,Ptr> Self;
_ListIterator(Node* node)
:_node(node)
{}
_ListIterator()
{}
Ref operator*()
{
return _node->_data;
}
/*Ref operator->()
{
return *this;
}*/
bool operator==(const Self& s)
{

return _node==s._node;
}
bool operator!=(const Self& s)
{
return _node!=s._node;
}
Self& operator++()//后置++，返回++之后的值
{

_node=_node->_next;
return *this;
}
Self& operator++(int)//前置++，返回++之前的值
{
Self tmp(_node);
_node=_node->_next;
return tmp;
}
Self& operator--()//后置--，返回--后的值
{
_node=_node->_prev;
return *this;
}
Self& operator--(int)//前置--，返回--前的值
{
Self tmp(_node);
_node=_node->_prev;
return tmp;
}
Node* _node;
};

模拟list取名MyList

template<class T>
class MyList
{
typedef _ListNode<T> Node;
public:
typedef _ListIterator<T,T&,T*> Iterator;
typedef _ListIterator<T,const T&,const T*> ConstIterator;
Node* BuyNode(const T& x)
{

Node* node=new Node(x);
return node;
}
MyList()
{
_Head=BuyNode(T());
_Head->_next=_Head;
_Head->_prev=_Head;
}
void PushBack(const T& x)
{
Insert(End(),x);
}
void PushFront(const T& x)
{

Insert(Begin(),x);
}
void PopFront()
{
Earse(Begin());
}
void Insert(Iterator Pos,const T&x)
{
Node* cur=Pos._node;
Node* prev=cur->_prev;
Node* tmp=BuyNode(x);
tmp->_next=cur;
cur->_prev=tmp;
prev->_next=tmp;
tmp->_prev=prev;

}
void Earse(Iterator Pos)
{

assert(Pos!=End());
Node* cur=Pos._node;
Node* prev=cur->_prev;
Node* next=cur->_next;
next->_prev=prev;
prev->_next=next;

}

Node* Find(const T& x)
{
Node* cur=_Head;
while(cur)
{
if(cur->_data==x)

break;

cur=cur->_next;

}
return cur;
}

<pre name="code" class="cpp">Iterator Begin()
{
return Iterator(_Head->_next);
}
Iterator End()
{
return Iterator(_Head);
}
Node* _Head;
};

测试函数

#include <iostream>
#include<cstdlib>
#include<ctime>
#include "MyList.h"
using namespace std;
void ListTest()
{

<pre name="code" class="cpp">	MyList<int> l;
l.PushBack(1);
l.PushBack(2);
l.PushBack(3);
l.PushBack(4);
l.PushBack(5);
l.Earse(l.Find(3));
l.PushFront(7);
l.PushFront(8);
l.PushFront(9);
l.PopFront();
MyList<int>::Iterator iter=l.Begin();
while (iter!=l.End())
{
cout<<*iter<<" ";
++iter;
}
cout<<endl;

<pre name="code" class="cpp">}
int main()
{
long start,end;
start=clock();
ListTest();
end=clock();
cout<<end-start<<endl;
system("pause");
return 0;
}

由于我的编译器太卡，所以用了一个clock()测试程序运行时间，但是没有什么卵用，测试1秒，出个程序至少30秒，这他吗就尴尬了

哈哈哈哈哈哈