与栈结合的二叉树遍历（c语言）

#include <stdio.h>
#include <stdlib.h>


#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define STACK_INIT_SIZE 100
#define maxsize 60
typedef int Status;
typedef struct BitNode
{
	char data;
	struct BitNode *lchild ,*rchild;

}BitNode, *BitTree;

typedef struct {
	int *base;
	int *top;
	int stackSize;
} SqStack;

typedef struct {
	BitTree *base;
	BitTree *top;
	int stackSize;
} bitStack;



Status InitStack (SqStack &S);
Status push(int e,SqStack &S);
Status pop(SqStack  &S,int &e);
Status getTop(SqStack &S);
Status StackEmpty(SqStack S);

void conversion();

void CreateBtree(BitTree &T );
void fInOrder(BitTree root);
void fPreOrder(BitTree T);
void inOrder(BitTree T);
void postOrder(BitTree b);

int main (){
	//conversion();
	BitTree T;
	CreateBtree(T);
	//输入树例如（包含空格在里面）
	//”ABC  DE G  F   “
    inOrder(T);
    printf("\n");
	fInOrder(T);
	printf("\n");
	fPreOrder(T);
    printf("\n");
	postOrder(T);
    return 0;
}

Status InitStack (SqStack &S){
	//S.base=(int *)malloc(STACK_INIT_SIZE*sizeof(int));
	S.base=new int[maxsize];
	if(!S.base)return OVERFLOW;
	S.top=S.base;
	S.stackSize=maxsize;
	return OK;
}
Status InitbitStack (bitStack &S){
	//S.base=(int *)malloc(STACK_INIT_SIZE*sizeof(int));
	S.base=new BitTree[maxsize];
	if(!S.base)return OVERFLOW;
	S.top=S.base;
	S.stackSize=maxsize;
	return OK;
}
Status push(SqStack &S,int e)
{
	if(S.top-S.base>=S.stackSize){
		return OVERFLOW;
	}
	*S.top++=e;

	return OK;
}
Status pushTree(bitStack &S,BitTree e)
{
	if(S.top-S.base>=S.stackSize){
		return OVERFLOW;
	}
	*S.top++=e;

	return OK;
}
Status pop(SqStack  &S,int &e)
{
	if(S.top==S.base){
		return ERROR;
	}
	e=*--S.top;

	return OK;
}
Status popTree(bitStack  &S,BitTree &e)
{
	if(S.top==S.base){
		return ERROR;
	}
	e=*--S.top;

	return OK;
}
Status getTop(SqStack &S){
	if(S.top==S.base){
		return ERROR;
	}
	return *(S.top-1);
}
Status StackEmpty(SqStack S){
	if(S.base==S.top)return ERROR;
	return OK;
}
Status bitStackEmpty(bitStack S){
	if(S.base==S.top)return ERROR;
	return OK;
}

void conversion(){
    //栈的小应用，十进制八进制转换
	SqStack S;
	InitStack(S);
	int N=0;
	scanf("%d",&N);
	while(N){
		push(S,N%8);
		N=N/8;
	}

	while (StackEmpty(S)){
		int e;
		pop (S,e);
		printf("%d",e);

	}
	printf("w2");

}



///递归方式遍历

void preOrder (BitTree T){
	if(T){
		printf("%c",T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}

}
void inOrder(BitTree T)
{
    if(T){
        printf("%c",T->data);
        preOrder(T->lchild);
        preOrder(T->rchild);
    }

}
void baOrder(BitTree T)
{
    if(T){
        printf("%c",T->data);
        preOrder(T->lchild);
        preOrder(T->rchild);
    }

}


void fInOrder(BitTree p){
    ///非递归的中序遍历
    bitStack S;
	InitbitStack(S);
	while (p!=NULL|| bitStackEmpty(S))
	{
		if (p!=NULL)
		{
			pushTree(S,p);

			p=p->lchild;
		}
		else{
            popTree(S,p);
            printf("%c",p->data);
            p=p->rchild;
		}
	}
}
void fPreOrder(BitTree b){
    BitTree st[maxsize];
    BitTree p;
    int top=-1;
    if(b!=NULL){
        st[++top]=b;  //根节点进栈
        while(top>-1){
            p=st[top--];//出栈并访问该节点;
            printf("%c",p->data);
            if(p->rchild!=NULL){st[++top]=p->rchild;}//右孩子节点进栈
            if(p->lchild!=NULL){st[++top]=p->lchild;}//左孩子节点进栈
        }

    }

}

void CreateBtree(BitTree &T ){
    //创建二叉树
    char ch;
    scanf("%c",&ch);
    if(ch==' ') T=NULL;
    else{
        if(!(T=(BitNode * )malloc(sizeof(BitNode)))) exit(OVERFLOW);

        T->data=ch;
        CreateBtree(T->lchild);
        CreateBtree(T->rchild);
    }
}

void postOrder(BitTree b){
    ///非递归的后序遍历
    BitTree st[maxsize];
    BitTree p;
    int flag,top=-1;
    if(b!=NULL){
    do{
        while (b!=NULL){
            st[++top]=b;
            b=b->lchild;
        }
        p=NULL;
         flag=1;
        while(top!=-1&&flag){
            b=st[top];
            if(b->rchild==p){
                printf("%c",b->data);
                top--;
                p=b;
            }
            else{
                b=b->rchild;
                flag=0;
            }
        }
    }while(top!=-1);
    }
}