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

1，树的递归创建
创建树的类，先创建struct TreeNode的节点
对于 char* ch=”abd###ce##f”的字符串创建树，遇到#为空
2，特殊情况：记得对节点指针的有效性判断

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;

        }
    }

2树的非递归遍历

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;

            }

        }
    }