迭代器的使用之双向循环链表

模拟实现迭代器和用迭代器的方式实现双向循环链表

   什仫是迭代器？>

     迭代器是一个抽象的设计概念，它的定义为：提供一种方法，使之能够依序巡访某个容器所含的各个元素，而又无需暴露该聚合物的内部表述方式.

  迭代器的设计思维>

    将数据容器和算法分开，彼此独立设计，最后再以一帖胶着剂将他们撮合在一起.

  迭代器到底是什仫呢？>

    迭代器是类似智能指针的对象,在实现中我们可以想当然的把它看作一个指针对象而已.下面是智能指针的一点介绍：

http://blog.csdn.net/qq_34328833/article/details/52432418

 

   --------------------------------------------

    双向循环链表>

       将双链表的终端结点的后继指针域由空指针改为指向头结点，而头结点的前驱指针域指向的则是终端结点，这种头尾相接的双链表称为双向循环链表.

    双向循环链表的插入和删除>

       

  -------------------------------------

下面就让我们开始造轮子

     模拟实现一个简单的迭代器：

       

template
struct Iterator
{
	typedef LinkNode Node;
	typedef Iterator Sef;

	Iterator(Node *node)
		:_node(node)
	{}
	Iterator()   //默认的构造函数
	{}

	bool operator == (const Sef& s)const
	{
		return _node == s._node;
	}
	bool operator != (const Sef& s)const
	{
		return _node != s._node;
	}
	Ref operator*()
	{
		return _node->_data;
	}
	Ptr operator->()
	{
		return _node;
	}
	Sef& operator++()   //前置++
	{
		_node=_node->_next;
		return *this;
	}
	Sef operator++(int)   //后置++
	{
		Sef tmp(*this);
		_node=_node->_next;
		return tmp;
	}
	Sef& operator--()     //前置--
	{
		_node=_node->_prev;
		return *this;
	}
	Sef operator--(int)   //后置--
	{
		Sef tmp(*this);
		_node=_node->_prev;
		return tmp;
	}
	Node *_node;
};

 

 

     模拟实现双向循环链表：

       

#pragma once
#include
#include
using namespace std;

template
struct LinkNode
{
	LinkNode *_next;
	LinkNode *_prev;
	T _data;
	LinkNode(const T& x)
		:_data(x)
		,_next(NULL)
		,_prev(NULL)
	{}
};

template
struct Iterator
{
	typedef LinkNode Node;
	typedef Iterator Sef;

	Iterator(Node *node)
		:_node(node)
	{}
	Iterator()   //默认的构造函数
	{}

	bool operator == (const Sef& s)const
	{
		return _node == s._node;
	}
	bool operator != (const Sef& s)const
	{
		return _node != s._node;
	}
	Ref operator*()
	{
		return _node->_data;
	}
	Ptr operator->()
	{
		return _node;
	}
	Sef& operator++()   //前置++
	{
		_node=_node->_next;
		return *this;
	}
	Sef operator++(int)   //后置++
	{
		Sef tmp(*this);
		_node=_node->_next;
		return tmp;
	}
	Sef& operator--()     //前置--
	{
		_node=_node->_prev;
		return *this;
	}
	Sef operator--(int)   //后置--
	{
		Sef tmp(*this);
		_node=_node->_prev;
		return tmp;
	}
	Node *_node;
};

template
class LinkList
{
	typedef LinkNode Node;
public:
	typedef Iterator LinkIterator;

	LinkList()
	{
		_head=CreatNode(T()); //传默认参数
		_head->_next=_head;   //设置哨兵
		_head->_prev=_head;
	}
	LinkList(const LinkList& l)
	{
		_head=CreatNode(T());
		_head->_next=_head;
		_head->_prev=_head;

		Node *cur=l._head->_next;
		while(cur != l._head)
		{
			Insert(End(),cur->_data);
			cur=cur->_next;
		}
	}
	LinkList& operator=(LinkList l)
	{
		std::swap(_head,l._head);
		return *this;
	}
	~LinkList()
	{
		Node *cur=_head->_next;
		while(cur != _head)
		{
			Node *del=cur;
			cur=cur->_next;
			delete del;
			del=NULL;
		}
		delete _head;
	}
public:
	//void PushBack(const T& x)
	//{
	//	Node *tail=_head->_prev;
	//	Node *NewNode=CreatNode(x);
	//	tail->_next=NewNode;
	//	NewNode->_prev=tail;

	//	NewNode->_next=_head;
	//	_head->_prev=NewNode;
	//}
	void PushBack(const T& x)
	{
		Insert(End(),x);
	}
	void PushFront(const T& x)
	{
		Insert(Begin(),x);
	}
	void PopBack()
	{
		Erase(--End());
	}
	void PopFront()
	{
		Erase(Begin());
	}
	void Insert(LinkIterator pos,const T& x)  //在指定位置前插
	{
		Node *cur=pos._node;
		Node *prev=cur->_prev;
		Node *NewNode=CreatNode(x);

		NewNode->_next=cur;
		cur->_prev=NewNode;
		prev->_next=NewNode;
		NewNode->_prev=prev;
	}
	void Erase(LinkIterator pos)
	{
		assert(pos != End());   //删除的不是哨兵
		Node *del=pos._node;
		del->_prev->_next=del->_next;
		del->_next->_prev=del->_prev;
		delete del;
		del=NULL;
	}
	LinkIterator Begin()
	{
		return LinkIterator(_head->_next);
	}
	LinkIterator End()
	{
		return LinkIterator(_head);
	}
protected:
	Node* CreatNode(const T& x)
	{
		Node *NewNode=new Node(x);
		return NewNode;
	}
protected:
	Node* _head;
};

 

 

     测试代码：

         

void testIterator()
{
	LinkList l;

	for(int i=0;i<10;i++)
	{
		l.PushBack(i+1);
	}
	LinkList::LinkIterator it=l.Begin();
	while(it != l.End())
	{
		cout<<*it<<" ";
		++it;
	}
	cout<::LinkIterator it1=l.Begin();
	while(it1 != l.End())
	{
		cout<<*it1<<" ";
		++it1;
	}
	cout< l1;
	for(int i=0;i<10;i++)
	{
		l1.PushFront(i+1);
	}

	LinkList::LinkIterator it=l1.Begin();
	while(it != l1.End())
	{
		cout<<*it<<" ";
		++it;
	}
	cout<::LinkIterator it1=l1.Begin();
	while(it1 != l1.End())
	{
		cout<<*it1<<" ";
		++it1;
	}
	cout< l1;
	l1.PushBack(1);
	l1.PushBack(2);
	l1.PushBack(3);
	l1.PushBack(4);

	LinkList::LinkIterator it=l1.Begin();
	while(it != l1.End())
	{
		cout<<*it<<" ";
		++it;
	}
	cout< l2(l1);
	l2.PushBack(5);
	LinkList::LinkIterator it1=l2.Begin();
	while(it1 != l2.End())
	{
		cout<<*it1<<" ";
		++it1;
	}
	cout<::LinkIterator it2=l1.Begin();
	while(it2 != l1.End())
	{
		cout<<*it2<<" ";
		++it2;
	}
	cout<

 

  -------------------------------------

 对于迭代器的理解和简单模拟就结束了....