非递归后续遍历二叉树死循环！

加入printf("%c\n",s->data);后如下

int main(){
    char a[]={'e','d','b','a','c','f','g'};
    char b[]={'a','b','d','c','e','f','g'};
    bitree s;
    s=creatree(a,b,0,6,0,6);//建立二叉树
    printf("%c\n",s->data);
    LRN(s);//后序遍历--非递归
    //LNRD(s);后序遍历--递归
    printf("\nover!\n");
    return 0;
}

不加printf他就进入死循环，究竟为什么

int main(){
    char a[]={'e','d','b','a','c','f','g'};
    char b[]={'a','b','d','c','e','f','g'};
    bitree s;
    s=creatree(a,b,0,6,0,6);//建立二叉树
    //printf("%c\n",s->data);
    LRN(s);//后序遍历--非递归
    //LNRD(s);后序遍历--递归
    printf("\nover!\n");
    return 0;
}

完整代码如下

#include <stdio.h>
#include <stdlib.h>
//定义树结点
typedef struct node{
    char data;
    struct node * lchild, * rchild;
}*bitree;
//定义栈结点
typedef struct linknode{
    bitree  data;
    struct linknode * next;
}*linkstack;
typedef struct stack{
    linknode * base;
    linknode * top;
}stack;
//初始化栈(带头结点)
void initstack(stack * pstack){
    pstack->base=pstack->top=(linkstack)malloc(sizeof(linknode));
    pstack->base->next=NULL;
}
//判空
bool isempty(stack * p){
    if(p->top==p->base) return true;
    else return false;
}
//出栈操作，删除单链表的尾结点，需从头遍历找到尾结点的前驱结点
void pop(stack * p, node * q){
    if(p->base==p->top) return;
    linknode * s = p->base;//s指向头结点，注意头结点的下一个结点为第一个结点
    while(s->next!=p->top){
        s=s->next;
    }
    q=p->top->data;
    free(p->top);
    p->top=s;
    s->next=NULL;
}
//入栈操作
void push(stack * p,node * q){
    linknode*pp=(linknode*)malloc(sizeof(linknode));
    pp->data=q;
    pp->next=NULL;
    p->top->next=pp;
    p->top=pp;
}
//读取栈顶元素并用q返回
void gettop(stack * p, node * &q){
    //判空
    if(p->top!=p->base){
        q=p->top->data;
    }
}
void visit(char p){
    printf("%c",p);
}
//递归法+中序先序建立二叉树
bitree creatree(char a[],char b[],int a1,int a2, int b1, int b2){
    bitree root;
    root=(bitree)malloc(sizeof(node));
    root->data=a[a1];
    int i,llen,rlen;
    for (i=b1;b[i]!=root->data;i++);
    llen=i-b1;
    rlen=b2-i;
    if (llen){
        root->lchild= creatree(a,b,a1+1,a1+llen,b1,b1+llen-1);
    }else{
        root->lchild=NULL;
    }
    if(rlen){
        root->rchild= creatree(a,b,a2-rlen+1,a2,b2-rlen+1,b2);
    }else{
        root->rchild=NULL;
    }
    return root;
}
//后序遍历二叉树（递归）
void LNRD(bitree t){
    if(t){
        LNRD(t->lchild);
        LNRD(t->rchild);
        visit(t->data);
    }
}
//后序遍历二叉树(非递归)
void LRN(bitree t){
    stack * s;
    initstack(s);
    bitree p=t;
    bitree r=NULL;
    printf("begin!\n");
    while(p || !isempty(s)){
        if(p){
            push(s,p);
            printf("入栈完毕！");
            p=p->lchild;
        }else{
            gettop(s,p);
            if(p->rchild && p->rchild!=r){
                p=p->rchild;
                push(s,p);
                p=p->lchild;
            }else{
                pop(s,p);
                visit(p->data);
                r=p;
                p=NULL;
            }
        }
    }
}
int main(){
    char a[]={'e','d','b','a','c','f','g'};
    char b[]={'a','b','d','c','e','f','g'};
    bitree s;
    s=creatree(a,b,0,6,0,6);//建立二叉树
    printf("%c\n",s->data);
    LRN(s);//后序遍历--非递归
    //LNRD(s);后序遍历--递归
    printf("\nover!\n");
    return 0;
}

本人跨考学生，自学不易请各位多多指教！

for (i=b1;b[i]!=root->data;i++);
这个循环当找到b[i]=root->data后，i还会加1的，这个你是已经考虑了吗？