对树的一些操作.比如遍历.比如.根据先序和中序创建二叉树

#include "stdafx.h"
#include<string>
#include<iostream>
#include<stack>

using namespace std;

struct BinaryTreeNode
{
    int m_nValue;
    BinaryTreeNode* m_pLeft;
    BinaryTreeNode* m_pRight;
};

void beforeTraverse(BinaryTreeNode *root)
{
    if(root!=NULL)
    {
        cout<<root->m_nValue<<"  ";
        beforeTraverse(root->m_pLeft);
        beforeTraverse(root->m_pRight);
    }
}

void PreOrder(BinaryTreeNode* pRoot)
{//迭代先序遍历
    if (pRoot==NULL)
        return;
    std::stack<BinaryTreeNode*> S;
    BinaryTreeNode *p=pRoot;   //二叉树分左右，所以光有栈不行，合理的运用遍历指针是关键之一
    while(p!=NULL)
    {
        cout<<p->m_nValue<<"  ";
        if (p->m_pRight!=NULL)
            S.push(p->m_pRight);
        if (p->m_pLeft!=NULL)
            p=p->m_pLeft;
        else
        {
            if (S.empty())
                break;
            p=S.top();
            S.pop();
        }
    }
}




void midTraverse(BinaryTreeNode *root)
{
    if(root!=NULL)
    {
        midTraverse(root->m_pLeft);
        cout<<root->m_nValue<<"  ";
        midTraverse(root->m_pRight);
    }
}


void InOrder(BinaryTreeNode* pRoot)
{//迭代中序遍历
    if (pRoot==NULL)
        return;
    std::stack<BinaryTreeNode*> S;
    BinaryTreeNode *p=pRoot;
    do 
    {
        while(p!=NULL)
        {
            S.push(p);
            p=p->m_pLeft;
        }
        若进行到这里左子树为空
        if (!S.empty())//Stack不空时退栈，然后访问该元素
        {
            p=S.top();
            cout<<p->m_nValue<<"  ";
            S.pop();
            p=p->m_pRight;
        }
    } while (p!=NULL||!S.empty());
    这里的p==NULL表示右子树为空，然后堆栈如果也空的话，才是处理完毕
}

void backTraverse(BinaryTreeNode *root)
{
    if(root!=NULL)
    {
        backTraverse(root->m_pLeft);
        backTraverse(root->m_pRight);
        cout<<root->m_nValue<<"  ";
    }
}

void PostOrder(BinaryTreeNode* pRoot)
{
    if (pRoot==NULL)
        return;
    std::pair<BinaryTreeNode*,char> w;
    std::stack<std::pair<BinaryTreeNode*,char> > S;
    BinaryTreeNode *p=pRoot;      
    do 
    {
        while(p!=NULL)           //左子树经过节点加L进栈
        {
            w.first=p;
            w.second='L';
            S.push(w);
            p=p->m_pLeft;
        }
        bool continuel=true;     //继续循环标志，用于L改为R的时候就开始向右遍历
        while (continuel && !S.empty()) //用一个break语句也能实现循环标志continuel的功能
        {
            w=S.top();
            S.pop();
            p=w.first;
            if (w.second=='L')  //标记为L表示左子树遍历完
            {
                w.second='R';
                S.push(w);
                continuel=false;
                p=p->m_pRight;
            }
            else
                cout<<(p->m_nValue)<<"   ";      //如果标记为R，表示右子树遍历完
        }
    }while (!S.empty());
}

BinaryTreeNode* createTree(int *leftArr,int leftarrl,int leftarrr,int *midArr,int midarrl,int midarrr)
{
    if(leftarrl<=leftarrr){
        BinaryTreeNode* root =new BinaryTreeNode;
        root->m_nValue= leftArr[leftarrl];//取先序遍历的第一个元素作为根节点
        取出这个结点以后..要在midArr里面找到这个节点
        int temIndex = -1;

        for(int i = midarrl;i<=midarrr;++i)
        {
            if(midArr[i]==leftArr[leftarrl])
            {
                temIndex =i;
                break;
            }
        }
        if(temIndex==-1)
        {
            cout<<"数据有误"<<endl;
            throw std::exception("valid data");
            
        }
        int lengthl = temIndex-midarrl;
        root->m_pLeft = createTree(leftArr,leftarrl+1,leftarrl+lengthl,midArr,midarrl,temIndex-1);
        root->m_pRight =createTree(leftArr,leftarrl+lengthl+1,leftarrr,midArr,temIndex+1,midarrr);
        return root;
}
    else
    {
        return NULL;
    }
}
BinaryTreeNode* cTree(int *leftArr,int *midArr,int len)
{
    return createTree(leftArr,0,len-1,midArr,0,len-1);
}

//生成一颗镜像树,递归实现
BinaryTreeNode* Recursion(BinaryTreeNode* T)
{
    if(T==NULL)
        return NULL;
    BinaryTreeNode* Node = new BinaryTreeNode;
    Node->m_nValue = T->m_nValue;
    Node->m_pLeft = Recursion(T->m_pRight);
    Node->m_pRight = Recursion(T->m_pLeft);
    return Node;
}

int _tmain(int argc, _TCHAR* argv[])
{
    
    BinaryTreeNode *roots = new BinaryTreeNode;
    roots->m_nValue=1;
    BinaryTreeNode *lchild = new BinaryTreeNode;
    lchild->m_nValue = 2;
    lchild->m_pLeft=lchild->m_pRight=NULL;
    BinaryTreeNode *rchild = new BinaryTreeNode;
    rchild->m_nValue = 3;
    rchild->m_pLeft=rchild->m_pRight=NULL;
    roots->m_pLeft = lchild;
    roots->m_pRight = rchild; 


    beforeTraverse(roots);
    cout<<endl;
    midTraverse(roots);
    cout<<endl;
    BinaryTreeNode *reroot=Recursion(roots);
       beforeTraverse(reroot);
           cout<<endl;
    midTraverse(reroot);
    cout<<endl;
    cout<<endl;

    cout<<endl;
    backTraverse(roots);
    cout<<endl;

    //下面根据先序和中序构建一棵树
    const int len = 8;
    int left[]={1,2,4,7,3,5,6,8};
    int mid[]={4,7,2,1,5,3,8,6};
    BinaryTreeNode *root;
    root = cTree(left,mid,len);
    
    cout<<"先序遍历:";
    beforeTraverse(root);
    cout<<endl;
    cout<<"迭代版先序遍历:";
    PreOrder(root);
    cout<<endl;
    cout<<"中序遍历:";
    midTraverse(root);
    cout<<endl;
    cout<<"迭代中序遍历:";
    InOrder(root);
    cout<<endl;
    cout<<"后序遍历:";
    backTraverse(root);
    cout<<endl;
    cout<<"迭代后序遍历:";
    PostOrder(root);
    cout<<endl;
    return 0;
}