一棵完全二叉树采取顺序存储结构，存储的节点依次存放于一维数组 BT[0..n-1]中，写出中序遍历二 叉树的非递归算法

#include <stdio.h>
#include <string.h>
#include <malloc.h>
#define M 20

typedef struct BTNode{
    
    
    char c;
    struct BTNode *lchild,*rchild;
};

typedef struct BTNode * BTNodeptr;

BTNodeptr stack[M];
BTNodeptr root;

//在祖先树中找结点
BTNodeptr find_node(BTNodeptr np,char c){
    
    
    BTNodeptr result=NULL;
    if(np){
    
    
        if(np->c==c)
            result=np;
        else{
    
    
            result=find_node(np->lchild,c);
            if(result==NULL)
                result=find_node(np->rchild,c);
        }
    }
    return result;
}

void visit(BTNodeptr p){
    
    
    printf("%c",p->c);
}

void inorder(BTNodeptr t){
    
    
    BTNodeptr p=t;
    int top=-1;
    if(t!=NULL){
    
    
        do{
    
    
            for(;p!=NULL;p=p->lchild)
                stack[++top]=p;
            p=stack[top--];
            visit(p);
            p=p->rchild;
        }while(!(p==NULL&&top==-1));
    }
}

BTNodeptr make_node(){
    
    
    BTNodeptr p=(BTNodeptr)malloc(sizeof(struct BTNode));
    p->c=0;
    p->rchild=p->lchild=NULL;
    return p;
}

int main(){
    
    
    char ns[10]="ABCDEFG";
    int len=strlen(ns);
    int i,j;
    BTNodeptr p,q;
    BTNodeptr l,r;
    for(i=0;i<len;i++){
    
    
        if(root==NULL){
    
    
            root=make_node();
            root->c=ns[i];
            p=root;
        }
        else{
    
    
            p=find_node(root,ns[i]);
        }
        if(i*2+1<len){
    
    
            l=make_node();
            l->c=ns[i*2+1];
            p->lchild=l;
        }
        else
            break;
        if(i*2+2<len){
    
    
            r=make_node();
            r->c=ns[i*2+2];
            p->rchild=r;
        }
        else
            break;
    }

    inorder(root);
}