【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秒，这他吗就尴尬了

哈哈哈哈哈哈