二叉树的各种遍历

    // 前序：访问根节点--->访问根节点的左子树--->访问根节点的右子树
    void _PreOrder(Node* pRoot)  
    {
        if (pRoot)
        {
            cout << pRoot->_value << " ";
            _PreOrder(pRoot->_pLeft);
            _PreOrder(pRoot->_pRight);
        }
    }
    //前序遍历非递归
    void _PreOrder_Nor(Node*pRoot)
    {
        if (NULL == pRoot)
            return;
        stack<Node*>s;
        s.push(pRoot);
        while (!s.empty())
        {
            Node*pCur = s.top();
            cout << pCur->_value << " ";
            s.pop();
            if (pCur->_pRight)
                s.push(pCur->_pRight);
            if (pCur->_pLeft)
                s.push(pCur->_pLeft);
        }
    }
    //中序遍历递归
    void _InOrder(Node* pRoot)
    {
        if (pRoot)
        { 
            _InOrder(pRoot->_pLeft);
            cout << pRoot->_value << " ";
            _InOrder(pRoot->_pRight);
        }
    }
    //中序遍历非递归
    void _InOrder_Nor(Node*pRoot)
    {
        if (NULL == pRoot)
            return;
        stack<Node*>s;
        Node*pCur = pRoot;
        while (pCur || !s.empty())
        {
            while (pCur)
            {  // 找到最左边的孩子，并把所经过路径的结点保存下来
                s.push(pCur);
                pCur = pCur->_pLeft;
            }
            //出了内层循环，pCur为空，栈顶元素为最左边的孩子
            pCur = s.top();
            cout << pCur->_value << " ";
            s.pop();
            pCur = pCur->_pRight;
        }
    }

    // 后序遍历：遍历根的左子树-->遍历根的右子树-->遍历根节点
    void _PostOrder(Node* pRoot)
    {
        if (pRoot)
        {
            _PostOrder(pRoot->_pLeft);
            _PostOrder(pRoot->_pRight);
            cout << pRoot->_value << " ";
        }
    }
    //后序遍历非递归
    void _PostOrder_Nor(Node*pRoot)
    {
        if (NULL == pRoot)
            return;
        stack<Node*>s;
        Node*pCur = pRoot;
        Node*Prev = NULL;//保存上次入栈的结点
        while (pCur || !s.empty())
        {
            while (pCur)
            {  // 找到最左边的孩子，并把所经过路径的结点保存下来
                s.push(pCur);
                pCur = pCur->_pLeft;
            }
            Node*pTop = s.top();
            if (NULL == pTop->_pRight || Prev == pTop->_pRight)//没有Prev == pTop->_pRight会4256666666......会死循环下去
            {   //Prev == pTop->_pRight右已经访问过了，才能访问当前的根    
                //NULL == pTop->_pRight  
                cout << pTop->_value << " ";
                Prev = pTop; //保存上次入栈的结点
                s.pop();
            }
            else
            {
                pCur = pTop;//pCur在while出来之后为NULL，所以要更新pCur的值，少了这句，崩溃
                pCur = pCur->_pRight;//将右子树当做一颗新的树去访问
            }
        }
    }

    // 层序遍历
    void _LevelOrder(Node*pRoot)//******考点********队列***
    {
        if (NULL == pRoot)
            return;
        queue<Node*>q;
        q.push(pRoot);//保存的是结点的地址，地址出了队列，但是树并没有改变
        while (!q.empty())
        {
            Node*pcur = q.front();
            cout << pcur->_value << " ";
            if (pcur->_pLeft)//左不为空入队列
            {
                q.push(pcur->_pLeft);
            }
            if (pcur->_pRight)//右不为空入队列
            {
                q.push(pcur->_pRight);
            }
            q.pop();
        }
        cout << endl;
    }