迭代器访问树

//节点是对某种类型数据的封装；通过这种封装，能够对这种数据建立树形模型

//Node是Data的马甲,穿上马甲的Data能够组织成一棵树

public abstract class Node<T>

{

protected T _data;

public T Data

{

get

{

return _data;

}

set

{

_data = value;

}

}

}

//定义子节点集合。这样定义节点有一个好处，如果获得一个节点的引用，也就引用的以该节点为根的整棵树

public class CldNode<T> : Node<T>

{

public CldNode(T data)

{

_data = data;

}

public CldNode()

{ }

private List<CldNode<T>> _children;

public List<CldNode<T>> Children

{

get

{

if (_children == null) //从单例模式改的，不知道有没有问题？

{

lock (this)

{

if (_children == null)

{

_children = new List<CldNode<T>>();

}

}

}

return _children;

}

}

}

//后面使用堆栈模拟遍历树，这个辅助类定义了堆栈中的元素。

//First表示堆栈中的节点，Second表示要遍历这个节点的第几个子

[Serializable]

public class Pair<FT, ST>

{

public Pair(FT first, ST second)

{

First = first;

Second = second;

}

public FT First

{

get;

set;

}

public ST Second

{

get;

set;

}

}

//不用递归是因为不知道用递归改怎么写成迭代器

public class CldNodeIterator<T>

{

private Stack<Pair<CldNode<T>, int>> _stack;

private CldNode<T> _root;

public CldNodeIterator(CldNode<T> root)

{

_root = root;

}

public CldNodeIterator() { }

public CldNode<T> Root

{

get

{

return _root;

}

set

{

_root = value;

}

}

//首先访问父节点

//然后访问所有的子结点

//上面这两点是递归的

public IEnumerable<T> FPermiseTraverse()

{

if (_stack == null)

{

_stack = new Stack<Pair<CldNode<T>, int>>(16);

}

_stack.Push(new Pair<CldNode<T>, int>(_root, -1));

while (_stack.Count != 0)

{

Pair<CldNode<T>, int> stkTop = _stack.Peek();

if (stkTop.Second == -1) //尚未开始遍历

{

yield return stkTop.First.Data;

stkTop.Second++;

continue;

}

if (stkTop.First.Children.Count == stkTop.Second) //已经结束

{

_stack.Pop();

if (_stack.Count != 0)

{

_stack.Peek().Second++;

}

continue;

}

_stack.Push(new Pair<CldNode<T>, int>(stkTop.First.Children[stkTop.Second], -1));

}

}

//先子后父

public IEnumerable<T> CPermiseTraverse()

{

if (_stack == null)

{

_stack = new Stack<Pair<CldNode<T>, int>>(16);

}

_stack.Push(new Pair<CldNode<T>, int>(_root, -1));

while (_stack.Count != 0)

{

Pair<CldNode<T>, int> stkTop = _stack.Peek();

if (stkTop.Second == -1) //尚未开始遍历

{

stkTop.Second++;

continue;

}

if (stkTop.First.Children.Count == stkTop.Second) //已经结束

{

yield return stkTop.First.Data;

_stack.Pop();

if (_stack.Count != 0)

{

_stack.Peek().Second++;

}

continue;

}

_stack.Push(new Pair<CldNode<T>, int>(stkTop.First.Children[stkTop.Second], -1));

}

}

}

//不知道有没有bug?我没仔细测。