迭代器

template<class T,class Ref,class Ptr>
struct __TreeIterator
{
	typedef BinTreeNode<T> Node;
	typedef __TreeIterator<T,Ref,Ptr> Self;
	__TreeIterator()
	{}
	__TreeIterator(Node* node)
		:_node(node)
	{}
	Ref operator*()
	{
		assert(_node);
		return _node->_date;
	}
	Self& operator++()
	{
		assert(_node);
		if(_node->RightTag==Link)
		{
			Node* right=_node->rightchild;
			while (right&&right->LeftTag==Link)
			{
				right=right->leftchild;
			}
			_node=right;
		}
		else
		{
			_node=_node->rightchild;
		}
		return *this;
	}
	Self& operator++(int)
	{
		Self tmp(*this);
		++(*this);
		return tmp;
	}
	Self& operator--()
	{
		assert(_node);
		if(_node->LeftTag=Link)
		{
			Node* left=_node->leftchild;
			while (left&&left->RightTag==Link)
			{
				left=left->rightchild;
			}
			_node=left;
		}
		else
		{
			_node=_node->leftchild;
		}
		return *this;
	}
	bool operator!=(const Self s) const
	{
		return _node!=s._node;
	}
	Node* _node;

二叉树的实现

需要实现begin和end

template <class T>
class BinTree
{
	typedef BinTreeNode<T> Node;
public:
	typedef __TreeIterator<T,T&,T*> Iterator;
	typedef __TreeIterator<T,const T&,const T* > ConstIterator;
	Iterator Begin()
	{
		Node* cur=_root;
		while (cur&&cur->LeftTag==Link)
		{
			cur=cur->leftchild;
		}
		return Iterator(cur);
	}
	ConstIterator Begin()const;
	Iterator End()
	{
		return Iterator(0);
	}
	ConstIterator End()const;
	BinTree()
		:_root(NULL)
	{}
	BinTree(T* a,size_t size,const T& invalid)
		:_root(NULL)
	{
		size_t index=0;
		_CreateTree( _root,a,size,index,invalid);
	}
	void InOrderThead()
	{
		Node* pre=NULL;
		_InOrderThead(_root,pre);
	}
protected:
	void  _CreateTree(Node*& root,T a[],size_t& index,const T& invalid)
	{
		assert(a);
		if(index< size&& a[index]!=invalid)
		{
			root=new Node(a[index]);
			_CreateTree(root->leftchild,++index,invalid);
			_CreateTree(root->rightchild,invalid);

		}
	}
	void _InOrderThead(Node* root,Node* &pre)
	{
     if(root==NULL)
	 return ;
	 _InOrderThead(root->leftchild,pre);
	 if(root->leftchild==NULL)
	 {
		 root->LeftTag=Thread;
		 root->leftchild=pre;
	 }
	 if(pre&&pre->rightchild==NULL)
	 {
		 pre->RightTag=Thread;
		 pre->rightchild=root;
	 }
	 pre=root;
	 _InOrderThead(root->rightchild,pre);
	}
private:
	Node* _root;
}; 

void test()
{
	int a1[10]={1,2,3,'#',4,5,6};
	BinTree<int> t1(a1,10,'#');
	t1.InOrderThead();
	//t1.InOrder_NonR();
	BinTree<int>::Iterator it=t1.Begin();
	cout<<endl;
	while (it!=t1.End())
	{
		cout<<*it<<" ";
		++it;
	}
	cout<<endl;
}