二叉树的前中后序递归与非递归遍历

先使用先序的方法建立一棵二叉树，然后分别使用递归与非递归的方法实现前序、中序、后序遍历二叉树，并使用了两种方法来进行层次遍历二叉树，一种方法就是使用STL中的queue，另外一种方法就是定义了一个数组队列，分别使用了front和rear两个数组的下标来表示入队与出队，还有两个操作就是求二叉树的深度、结点数。。。

#include<iostream>    
#include<queue>    
#include<stack>    
using namespace std;    

//二叉树结点的描述    
typedef struct BiTNode  
{    
    char data;    
    struct BiTNode *lchild, *rchild;      //左右孩子    
}BiTNode,*BiTree;    

//按先序遍历创建二叉树    
//BiTree *CreateBiTree()     //返回结点指针类型    
//void CreateBiTree(BiTree &root)      //引用类型的参数    
void CreateBiTree(BiTNode **root)    //二级指针作为函数参数    
{    
    char ch; //要插入的数据    
    scanf("\n%c", &ch);  
    //cin>>ch;    
    if(ch=='#')  
        *root = NULL;  
    else  
    {  
        *root = (BiTNode *)malloc(sizeof(BiTNode));  
        (*root)->data = ch;  
        printf("请输入%c的左孩子：",ch);  
        CreateBiTree(&((*root)->lchild));  
        printf("请输入%c的右孩子：",ch);  
        CreateBiTree(&((*root)->rchild));  
    }  
}  

//前序遍历的算法程序    
void PreOrder(BiTNode *root)  
{    
    if(root==NULL)    
        return ;    
    printf("%c ", root->data); //输出数据    
    PreOrder(root->lchild); //递归调用，前序遍历左子树    
    PreOrder(root->rchild); //递归调用，前序遍历右子树    
}    

//中序遍历的算法程序    
void InOrder(BiTNode *root)    
{    
    if(root==NULL)  
        return ;  
    InOrder(root->lchild); //递归调用，前序遍历左子树    
    printf("%c ", root->data); //输出数据    
    InOrder(root->rchild); //递归调用，前序遍历右子树    
}    

//后序遍历的算法程序    
void PostOrder(BiTNode *root)  
{  
    if(root==NULL)  
        return ;  
    PostOrder(root->lchild);      //递归调用，前序遍历左子树    
    PostOrder(root->rchild);      //递归调用，前序遍历右子树    
    printf("%c ", root->data);    //输出数据      
}    

/*  
二叉树的非递归前序遍历，前序遍历思想：先让根进栈，只要栈不为空，就可以做弹出操作，  
每次弹出一个结点，记得把它的左右结点都进栈，记得右子树先进栈，这样可以保证右子树在栈中总处于左子树的下面。  
*/    
void PreOrder_Nonrecursive(BiTree T)     //先序遍历的非递归      
{    
    if(!T)      
        return ;      

    stack<BiTree> s;    
    s.push(T);    

    while(!s.empty())    
    {    
        BiTree temp = s.top();    
        cout<<temp->data<<" ";    
        s.pop();    
        if(temp->rchild)    
            s.push(temp->rchild);    
        if(temp->lchild)    
            s.push(temp->lchild);    
    }    
}    

void PreOrder_Nonrecursive1(BiTree T)     //先序遍历的非递归   
{  
    if(!T)    
        return ;  
    stack<BiTree> s;  
    BiTree curr = T;  
    while(curr != NULL || !s.empty())  
    {  
        while(curr != NULL)  
        {  
            cout<<curr->data<<"  ";  
            s.push(curr);  
            curr = curr->lchild;  
        }  
        if(!s.empty())  
        {  
            curr = s.top();  
            s.pop();  
            curr = curr->rchild;  
        }  
    }  
}  

void PreOrder_Nonrecursive2(BiTree T)     //先序遍历的非递归    
{    
    if(!T)  
        return ;    

    stack<BiTree> s;    
    while(T)          // 左子树上的节点全部压入到栈中    
    {    
        s.push(T);    
        cout<<T->data<<"  ";    
        T = T->lchild;    
    }    

    while(!s.empty())    
    {            
        BiTree temp = s.top()->rchild;  // 栈顶元素的右子树    
        s.pop();                        // 弹出栈顶元素    
        while(temp)          // 栈顶元素存在右子树，则对右子树同样遍历到最下方    
        {    
            cout<<temp->data<<"  ";    
            s.push(temp);    
            temp = temp->lchild;    
        }    
    }    
}    

void InOrderTraverse1(BiTree T)   // 中序遍历的非递归    
{    
    if(!T)    
        return ;    
    BiTree curr = T;    // 指向当前要检查的节点    
    stack<BiTree> s;  
    while(curr != NULL || !s.empty())  
    {  
        while(curr != NULL)  
        {  
            s.push(curr);  
            curr = curr->lchild;  
        }//while  
        if(!s.empty())  
        {  
            curr = s.top();  
            s.pop();  
            cout<<curr->data<<"  ";  
            curr = curr->rchild;  
        }  
    }  
}  

void InOrderTraverse(BiTree T)   // 中序遍历的非递归    
{    
    if(!T)    
        return ;    
    stack<BiTree> s;    
    BiTree curr = T->lchild;    // 指向当前要检查的节点    
    s.push(T);    
    while(curr != NULL || !s.empty())    
    {    
        while(curr != NULL)    // 一直向左走    
        {    
            s.push(curr);    
            curr = curr->lchild;    
        }    
        curr = s.top();    
        s.pop();    
        cout<<curr->data<<"  ";    
        curr = curr->rchild;    
    }    
}    

void PostOrder_Nonrecursive1(BiTree T)  // 后序遍历的非递归      
{      
    stack<BiTree> S;      
    BiTree curr = T ;           // 指向当前要检查的节点    
    BiTree previsited = NULL;    // 指向前一个被访问的节点    
    while(curr != NULL || !S.empty())  // 栈空时结束      
    {      
        while(curr != NULL)            // 一直向左走直到为空    
        {      
            S.push(curr);      
            curr = curr->lchild;      
        }      
        curr = S.top();    
        // 当前节点的右孩子如果为空或者已经被访问，则访问当前节点    
        if(curr->rchild == NULL || curr->rchild == previsited)      
        {      
            cout<<curr->data<<"  ";      
            previsited = curr;      
            S.pop();      
            curr = NULL;      
        }      
        else    
            curr = curr->rchild;      // 否则访问右孩子    
    }      
}     

void PostOrder_Nonrecursive(BiTree T)  // 后序遍历的非递归     双栈法    
{      
    stack<BiTree> s1 , s2;      
    BiTree curr ;           // 指向当前要检查的节点    
    s1.push(T);    
    while(!s1.empty())  // 栈空时结束      
    {    
        curr = s1.top();    
        s1.pop();    
        s2.push(curr);    
        if(curr->lchild)    
            s1.push(curr->lchild);    
        if(curr->rchild)    
            s1.push(curr->rchild);    
    }    
    while(!s2.empty())    
    {    
        printf("%c ", s2.top()->data);    
        s2.pop();    
    }    
}    


int visit(BiTree T)    
{    
    if(T)    
    {    
        printf("%c ",T->data);    
        return 1;    
    }    
    else    
        return 0;    
}    

void LeverTraverse(BiTree T)   //方法一、非递归层次遍历二叉树     
{    
    queue <BiTree> Q;    
    BiTree p;    
    p = T;    
    if(visit(p)==1)    
        Q.push(p);    
    while(!Q.empty())    
    {    
        p = Q.front();    
        Q.pop();    
        if(visit(p->lchild) == 1)     
            Q.push(p->lchild);    
        if(visit(p->rchild) == 1)    
            Q.push(p->rchild);    
    }    
}    
void LevelOrder(BiTree BT)     //方法二、非递归层次遍历二叉树     
{    
    BiTNode *queue[10];//定义队列有十个空间    
    if (BT==NULL)    
        return;    
    int front,rear;    
    front=rear=0;    
    queue[rear++]=BT;    
    while(front!=rear)//如果队尾指针不等于对头指针时    
    {    
        cout<<queue[front]->data<<"  ";  //输出遍历结果    
        if(queue[front]->lchild!=NULL)  //将队首结点的左孩子指针入队列    
        {    
            queue[rear]=queue[front]->lchild;    
            rear++;    //队尾指针后移一位    
        }    
        if(queue[front]->rchild!=NULL)    
        {    
            queue[rear]=queue[front]->rchild;    //将队首结点的右孩子指针入队列    
            rear++;   //队尾指针后移一位    
        }    
        front++;    //对头指针后移一位    
    }    
}    

int depth(BiTNode *T)   //树的深度    
{    
    if(!T)    
        return 0;    
    int d1,d2;    
    d1=depth(T->lchild);    
    d2=depth(T->rchild);    
    return (d1>d2?d1:d2)+1;    
    //return (depth(T->lchild)>depth(T->rchild)?depth(T->lchild):depth(T->rchild))+1;    
}    
int CountNode(BiTNode *T)    
{    
    if(T == NULL)    
        return 0;    
    return 1+CountNode(T->lchild)+CountNode(T->rchild);    
}    

int main(void)    
{    
    BiTNode *root=NULL; //定义一个根结点    
    int flag=1,k;    
    printf(" 本程序实现二叉树的基本操作。\n");    
    printf("可以进行建立二叉树，递归先序、中序、后序遍历，非递归先序、中序遍历及非递归层序遍历等操作。\n");    

    while(flag)    
    {    
        printf("\n");    
        printf("|--------------------------------------------------------------|\n");    
        printf("| 二叉树的基本操作如下:       |\n");    
        printf("|   0.创建二叉树            |\n");    
        printf("|   1.递归先序遍历          |\n");    
        printf("|   2.递归中序遍历          |\n");    
        printf("|   3.递归后序遍历          |\n");    
        printf("|   4.非递归先序遍历        |\n");    
        printf("|   5.非递归中序遍历        |\n");    
        printf("|   6.非递归后序遍历        |\n");    
        printf("|   7.非递归层序遍历        |\n");    
        printf("|   8.二叉树的深度         |\n");    
        printf("|   9.二叉树的结点个数      |\n");    
        printf("|   10.退出程序           |\n");    
        printf("|--------------------------------------------------------------|\n");    
        printf("                        请选择功能：");    
        scanf("%d",&k);    
        switch(k)    
        {    
        case 0:    
            printf("请建立二叉树并输入二叉树的根节点：");    
            CreateBiTree(&root);    
            break;    
        case 1:    
            if(root)    
            {    
                printf("递归先序遍历二叉树的结果为：");    
                PreOrder(root);    
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 2:    
            if(root)    
            {    
                printf("递归中序遍历二叉树的结果为：");    
                InOrder(root);    
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 3:    
            if(root)    
            {    
                printf("递归后序遍历二叉树的结果为：");    
                PostOrder(root);    
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 4:    
            if(root)    
            {    
                printf("非递归先序遍历二叉树：");    
                PreOrder_Nonrecursive1(root);    
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 5:    
            if(root)    
            {    
                printf("非递归中序遍历二叉树：");    
                InOrderTraverse1(root);    
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 6:    
            if(root)    
            {    
                printf("非递归后序遍历二叉树：");    
                PostOrder_Nonrecursive(root);    
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 7:    
            if(root)    
            {    
                printf("非递归层序遍历二叉树：");    
                //LeverTraverse(root);    
                LevelOrder(root);    
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 8:    
            if(root)    
                printf("这棵二叉树的深度为：%d\n",depth(root));    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 9:    
            if(root)    
                printf("这棵二叉树的结点个数为：%d\n",CountNode(root));    
            else    
                printf("          二叉树为空！\n");    
            break;    
        default:    
            flag=0;    
            printf("程序运行结束，按任意键退出！\n");    
        }    
    }    
    system("pause");    
    return 0;    
}  

后序遍历的非递归的另外一种写法：

/* 
后序遍历由于遍历父节点是在遍历子节点之后，而且左节点和右节点遍历后的行为不一样， 
所以需要用变量来记录前一次访问的节点，根据前一次节点和现在的节点的关系来确定具体执行什么操作 
*/  
void Postorder(BiTree T)  
{  
    if(T == NULL)  
        return ;  
    stack<BiTree> s;  
    BiTree prev = NULL , curr = NULL;  
    s.push(T);  
    while(!s.empty())  
    {  
        curr = s.top();  
        if(prev == NULL  || prev->lchild == curr || prev->rchild == curr)  
        {  
            if(curr->lchild != NULL)  
                s.push(curr->lchild);  
            else if(curr->rchild != NULL)  
                s.push(curr->rchild);  
        }  
        else if(curr->lchild == prev)  
        {  
            if(curr->rchild != NULL)  
                s.push(curr->rchild);  
        }  
        else  
        {  
            cout<<curr->data;  
            s.pop();  
        }  
        prev = curr;  
    }  
}  
输入二叉树中的两个节点，输出这两个结点在树中最低的共同父节点。
思路：遍历二叉树，找到一条从根节点开始到目的节点的路径，然后在两条路径上查找共同的父节点。
[cpp] view plain copy
// 得到一条从根节点开始到目的节点的路径  
bool GetNodePath(TreeNode *pRoot , TreeNode *pNode , vector<TreeNode *> &path)  
{  
    if(pRoot == NULL)  
        return false;  
    if(pRoot == pNode)  
        return true;  
    else if(GetNodePath(pRoot->lchild , pNode , path) )  
    {  
        path.push_back(pRoot->lchild);  
        return true;  
    }  
    else if(GetNodePath(pRoot->rchild , pNode , path) )  
    {  
        path.push_back(pRoot->rchild);  
        return true;  
    }  
    return false;  
}  
TreeNode *GetLastCommonNode(const vector<TreeNode *> &path1 , const vector<TreeNode *> &path2)  
{  
    vector<TreeNode *>::const_iterator iter1 = path1.begin();  
    vector<TreeNode *>::const_iterator iter2 = path2.begin();  
    TreeNode *pLast;  
    while(iter1 != path1.end() && iter2 != path2.end() )  
    {  
        if(*iter1 == *iter2)  
            pLast = *iter1;  
        else  
            break;  
        iter1++;  
        iter2++;  
    }  
    return pLast;  
}  
TreeNode *GetLastCommonParent(TreeNode *pRoot , TreeNode *pNode1 , TreeNode *pNode2)  
{  
    if(pRoot == NULL || pNode1 == NULL || pNode2 == NULL)  
        return  NULL;  
    vector<TreeNode *> path1;  
    GetNodePath(pRoot , pNode1 , path1);  

    vector<TreeNode *> path2;  
    GetNodePath(pRoot , pNode2 , path2);  
    return GetLastCommonNode(path1 , path2);  
}