二叉树的非递归遍历C实现

#include<stdio.h>
#include<stdlib.h>
#define maxsize 100
#define StackSize 30 /*假定预分配的栈空间最多为30*/
typedef struct TNode{
  char data;
  struct TNode *lchild,*rchild;
}TNode,*Tree;
typedef struct
{
    Tree data[maxsize];
    int top;
}Stack;//定义栈 因为要非递归遍历 要借助栈来实现
typedef Tree SDataType; /*栈的元素类型设为整型*/
//栈开始定义方法
void InitStack(Stack *S) /*初始栈*/
{ S->top=-1;
}
int StackEmpty(Stack *S) /*判栈空*/
{return S->top==-1;
}
int StackFull(Stack *S) /*判栈满*/
{return S->top==StackSize-1;
}
void Push(Stack *S, SDataType x) /*进栈*/
{if(StackFull(S))
printf("栈已满\n"); /*上溢退出*/
else S->data[++S->top]=x; /*栈顶指针加1后将x进栈*/
}
SDataType Pop(Stack *S) /*出栈*/
{if (StackEmpty(S))
printf("Stack underflow"); /*下溢退出*/
else return S->data[S->top--]; /*栈顶指针返回后将栈顶指针减1*/
}
SDataType StackTop(Stack *S) /*取栈顶元素*/
{if (StackEmpty(S))
printf("栈已空\n");
return S->data[S->top];
}
//////////////////////////////////////栈结束
//先序遍历非递归算法1
void preorder_unrecursion_traverse(Tree T)
{
Stack *S;
S=(Stack *)malloc(sizeof(Stack)*StackSize);
Tree p;
InitStack(S);Push(S,T); /*根指针进栈*/
while(!StackEmpty(S)) {
 while(p=StackTop(S)) {
  printf("%3c",p->data); /*访问入栈结点的数据域*/
        Push(S,p->lchild); /*向左走到尽头*/
     }
        p=Pop(S); /*空指针退栈*/
   if(!StackEmpty(S)){ /*输出结点，向右一步*/
 p=Pop(S);
     /* printf("%3c",p->data); */
    Push(S,p->rchild);
   }   
}
free(S);
}//PreOrderUnrec
//先序遍历非递归算法2
void preorder_unrecursion_traverse2(Tree p)
{
   if(!p) return;
   Stack *s;
   Tree t;
   s=(Stack *)malloc(sizeof(Stack)*StackSize);
   InitStack(s);
   Push(s,p);
   while(!StackEmpty(s))
   {
      t=StackTop(s);
       printf("%c\n",t->data);
      Pop(s);
       if(t->rchild) Push(s,t->rchild); 
       if(t->lchild) Push(s,t->lchild); 
    }
   free(s);
 }

//中序遍历非递归算法
void inorder_unrecursion_traverse(Tree T)
{
Stack *S;
S=(Stack *)malloc(sizeof(Stack)*StackSize);
Tree p=T;
InitStack(S);
while(!StackEmpty(S)||p) {
 if(p){
         Push(S,p); /*向左走到尽头*/
       p=p->lchild;
 }else { /*输出结点，向右一步*/
   p= Pop(S);
      printf("%3c",p->data);
      p=p->rchild;
   }   
}
free(S);
}//PreOrderUnrec
void post_unrecursion_traverse(Tree root)     //非递归后序遍历
{  Stack *s; 
s=(Stack *)malloc(sizeof(Stack)*StackSize);
InitStack(s);
Tree cur;       //当前结点   
Tree pre=NULL;  //前一次访问的结点 
Push(s,root);
while(!StackEmpty(s)){   
 cur=StackTop(s);   
 if((cur->lchild==NULL&&cur->rchild==NULL)||(pre!=NULL&&(pre==cur->lchild||pre==cur->rchild))){       
  printf("%3c",cur->data);  //如果当前结点没有孩子结点或者孩子节点都已被访问过     
    Pop(s);         
    pre=cur;       
 }else 
 {     
  if(cur->rchild!=NULL)       
   Push(s,cur->rchild);       
  if(cur->lchild!=NULL)     
   Push(s,cur->lchild);  
 } 
}  
}
//初始化二叉树
Tree create_tree(void){
  Tree T;
  char ch;
  scanf("%c",&ch);
  if(ch=='#')
     T=NULL;
    else { 
      if(!(T=(TNode*)malloc(sizeof(TNode))))
            exit(-2);
            T->data=ch;
            T->lchild=create_tree();
            T->rchild=create_tree();
        }
        return T;
}

void show_menu(){
printf("\t\t\t****二叉树简单算法****\n");
printf("\t\t\t~~~~~~~~~~~~~~~~~~~~~\n");
printf("\t\t\t#1. 先序非递归遍历 #\n");
printf("\t\t\t#2. 中序非递归遍历 #\n");
printf("\t\t\t#3. 后序非递归遍历 #\n");
printf("\t\t\t#4. 先序非递归遍历2 #\n");

}
int main(int argc, char* argv[])
{   
 int a;
 Tree T,p,q;
 int t,l,d,h,m,i;
 char ch;
 printf("\t\t\t***创建二叉树****\n");
 printf("请输入树的各元素，用#表示空节点\n");
 T=create_tree();
 while(1){
  show_menu();
  printf("请您选择(0-6):");
  scanf("%d",&t);
  switch(t){
  case 1:
      printf("◎先序非递归遍历:");
   preorder_unrecursion_traverse(T);
   printf("\n");
   break;

  case 2:
      printf("◎中序非递归遍历:");
  inorder_unrecursion_traverse(T);
   printf("\n");
   break;
 
  case 3:
      printf("◎后序非递归遍历:");
   post_unrecursion_traverse(T);
   printf("\n");
   break;
  
    case 4:
  printf("◎先序非递归遍历2:");
   preorder_unrecursion_traverse2(T);
   printf("\n");
   break;
       default:
     printf("      ※输入出错!!!请重输：\n");

 
  }
 }

scanf("%d",&a);
return 0;
}