二叉树先序，中序，后序遍历非递归实现

</pre><pre name="code" class="cpp">#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<stack>
using namespace std;
char in[30],pre[30],last[30];

typedef struct mynode
{
    char data;
    struct mynode* leftchild;
    struct mynode* rightchild;
} Node,*pNode;

void build(char *pre,char *in,int len,pNode &root)
{
    if(len<1)
        return;
    int i=0;
    while(pre[0]!=in[i])i++;
    root = (pNode)malloc(sizeof(Node));
    root->data = pre[0];
    root->rightchild = root->leftchild = NULL;
    build(pre+1,in,i,root->leftchild);
    build(pre+i+1,in+i+1,len-i-1,root->rightchild);
}

//层序遍历
void seqorder(pNode root)
{
    pNode temp;
    queue<pNode> qe;
    qe.push(root);
    while(!qe.empty())
    {
        temp = qe.front();
        qe.pop();
        printf("%c",temp->data);
        if(temp->leftchild)
            qe.push(temp->leftchild);
        if(temp->rightchild)
            qe.push(temp->rightchild);
    }
}

//中序遍历
void inorder(pNode root)
{
    if(NULL==root) return;
    inorder(root->leftchild);
    printf("%c",root->data);
    inorder(root->rightchild);

}

//前序遍历
void preorder(pNode root)
{
    if(NULL==root) return;
    printf("%c",root->data);
    preorder(root->leftchild);
    preorder(root->rightchild);
}

//后续遍历
void lastorder(pNode root)
{
    if(NULL==root)return;
    lastorder(root->leftchild);
    lastorder(root->rightchild);
    printf("%c",root->data);
}

//前序非递归
void _preorder(pNode root)
{
    stack<pNode> stk;
    while(!stk.empty()||root==NULL)
    {
        while(root)
        {
            stk.push(root);
            printf("%c",root->data);
            root = root->leftchild;
        }
        root = stk.top();
        root = root->rightchild;
        stk.pop();
    }
}
//中序遍历非递归
void _inorder(pNode root)
{
    stack<pNode> stk;

    while(root||!stk.empty())
    {
        while(root)
        {
            stk.push(root);
            root = root->leftchild;
        }
        root = stk.top();
        stk.pop();
        printf("%c",root->data);
        root = root->rightchild;
    }
}

//后续遍历非递归
void _lastorder(pNode root)
{
    int flag[30];
    stack<pNode> stk;
    while(root)
    {
        stk.push(root);
        flag[stk.size()] = 0;
        root = root->leftchild;
    }

    while(!stk.empty())
    {
        root = stk.top();
        while(root->rightchild&&flag[stk.size()]==0)
        {
            flag[stk.size()] = 1;
            root = root->rightchild;
            while(root)
            {
                stk.push(root);
                flag[stk.size()] = 0;
                root = root->leftchild;
            }
            root = stk.top();
        }
        printf("%c",root->data);
        stk.pop();
    }
}
int main(void)
{
    scanf("%s %s",pre,in);
    pNode root;
    build(pre,in,strlen(pre),root);
    //lastorder(root);
    _lastorder(root);
    return 0;
}