数据结构之树的创建及非递归遍历

template<class T>
struct TreeNode
{
TreeNode()
{}

TreeNode(T value)
{
data = value;
LeftTree = NULL;
RightTree = NULL;
}
T data;
TreeNode<T> *LeftTree;
TreeNode<T> *RightTree;
};

template<class T>
class Tree
{
public:
Tree()
:_pRoot(NULL)
{}

Tree(T* arr, size_t size)
:_pRoot(NULL)
{
size_t index = 0;
CreatTree(_pRoot, arr, size, index);
}

Tree(const Tree<T>& p)
{
if (p._pRoot != NULL)
_pRoot = CopyTree(p._pRoot);

}
Tree<T>& operator=(Tree<T>& p)
{
if (&p != this)
{
if (_pRoot != NULL)
{
Destory(_pRoot);
}

_pRoot = CopyTree(p._pRoot);

}

return  *this;
}
~Tree()
{
if (_pRoot != NULL)

{
Destory(_pRoot);
}
}
}
void CreatTree(TreeNode<T> *& pRoot, T *arr, size_t size, size_t &index)
{
if (pRoot == NULL && index<size && arr[index] != '#')
{
pRoot = new TreeNode<T>(arr[index]);
CreatTree(pRoot->LeftTree, arr, size, ++index);
CreatTree(pRoot->RightTree, arr, size, ++index);
}
}
TreeNode<T> *& CopyTree(TreeNode<T>* p)
{
TreeNode<T> * newpRoot;
if (p != NULL)
{
newpRoot = new TreeNode<T>(p->data);
newpRoot->LeftTree = CopyTree(p->LeftTree);
newpRoot->RightTree = CopyTree(p->RightTree);
return newpRoot;
}

}

void Destory(TreeNode<T> *& pRoot)
{

if (pRoot != NULL)
{
Destory(pRoot->LeftTree);
Destory(pRoot->RightTree);
delete  pRoot;
pRoot = NULL;

}
}

void RootFrontTree()
{
std::stack<TreeNode<T>*> s;
TreeNode<T>*  pCur = _pRoot;
s.push(pCur);
while (!s.empty())
{
TreeNode<T>* newTop = s.top();
cout << newTop->data;
s.pop();
if (newTop->RightTree != NULL)
s.push(newTop->RightTree);
if (newTop->LeftTree != NULL)
s.push(newTop->LeftTree);

}

}

void RootMidTree()
{
std::stack<TreeNode<T>*> s;
TreeNode<T>*  pCur = _pRoot;
while (!s.empty() || pCur != NULL)  //当把根的左子树遍历完，根节点也pop出来时，栈可能为空
{
while (pCur)          //找到最左边的：最左边的没左子树
{
s.push(pCur);
pCur = pCur->LeftTree;

}
TreeNode<T>* newTop = s.top();
if (newTop->RightTree == NULL)
{
cout << newTop->data;
s.pop();
}
else
{
cout << newTop->data;
pCur = newTop->RightTree;
s.pop();
}

}

}

void RootBackTree()
{
std::stack<TreeNode<T>*> s;
TreeNode<T>*  pCur = _pRoot;
TreeNode<T>* per = NULL;
while (!s.empty() || pCur != NULL) //刚进时为空
{
while (pCur)          //找到最左边的：最左边的没左子树
{
s.push(pCur);
pCur = pCur->LeftTree;

}
TreeNode<T>* newTop = s.top();
if (newTop->RightTree == NULL || per == newTop->RightTree)//打印1.没右子树 2.有右子树，但已经刚被打印过了
{

cout << newTop->data;
per = newTop;
s.pop();
}

else
{
pCur = newTop->RightTree;

}

}
}