二叉树三种遍历的非递归算法（背诵版）

二叉树三种遍历的非递归算法（背诵版）

给出二叉树先序、中序、后序三种遍历的非递归算法，此三个算法可视为标准算法，

1.先序遍历非递归算法
#define maxsize 100
typedef struct
{
    BitreeElem[maxsize];
    inttop;
}SqStack;

void PreOrderUnrec(Bitreet)
{
    SqStacks;
   StackInit(s);
    p=t;
   
    while(p!=null || !StackEmpty(s))
    {
       while(p!=null)            //遍历左子树
       {
           visite(p->data);
           push(s,p);
           p=p->lchild;      
       }//endwhile
       
       if(!StackEmpty(s))        //通过下一次循环中的内嵌while实现右子树遍历
       {
           p=pop(s);
           p=p->rchild;       
       }//endif
               
   }//endwhile
   
}//PreOrderUnrec

2.中序遍历非递归算法
#define maxsize 100
typedef struct
{
    BitreeElem[maxsize];
    inttop;
}SqStack;

void InOrderUnrec(Bitreet)
{
    SqStacks;
   StackInit(s);
    p=t;
    while(p!=null || !StackEmpty(s))
    {
       while(p!=null)            //遍历左子树
       {
           push(s,p);
           p=p->lchild;
       }//endwhile
       
       if (!StackEmpty(s))
       {
           p=pop(s);
           visite(p->data);       //访问根结点
           p=p->rchild;           //通过下一次循环实现右子树遍历
       }//endif  
   
   }//endwhile

}//InOrderUnrec

3.后序遍历非递归算法
#define maxsize 100
typedef enum{L,R} tagtype;
typedef struct
{
    Bitreeptr;
    tagtypetag;
}stacknode;

typedef struct
{
    stacknodeElem[maxsize];
    inttop;
}SqStack;

void PostOrderUnrec(Bitreet)
{
    SqStacks;
    stacknodex;
   StackInit(s);
    p=t;
   
    do
    {
       while(p!=null)       //遍历左子树
       {
           x.ptr = p;
           x.tag =L;        //标记为左子树
           push(s,x);
           p=p->lchild;
       }
   
       while (!StackEmpty(s) &&s.Elem[s.top].tag==R)
       {
           x = pop(s);
           p = x.ptr;
           visite(p->data);  //tag为R，表示右子树访问完毕，故访问根结点      
       }
       
       if (!StackEmpty(s))
       {
           s.Elem[s.top].tag=R;    //遍历右子树
           p=s.Elem[s.top].ptr->rchild;       
       }   
    }while(!StackEmpty(s));
}//PostOrderUnrec

typedef char DataType;
  typedef struct node{
  DataType data;
  struct node *lchild,*rchild;
  }BinTNode;

  typedef BinTNode *BinTree;

  int count;
  void CreateBinTree(BinTree *T);
  void PreorderN(BinTree T);

  #define StackSize 10
  typedef BinTree SDataType;
  #define Error printf
  typedef struct{
  SDataType data[StackSize];
  int top;
  }SeqStack;

  void InitStack(SeqStack *S)
  { S->top=-1; }
  int StackEmpty(SeqStack *S)
  {returnS->top==-1; }

  int StackFull(SeqStack *S)
  {returnS->top==StackSize-1;  }

  void Push(SeqStack *S, SDataType x)
  {if(StackFull(S))
  Error("栈已满\n");
  elseS->data[++S->top]=x; }

SDataType Pop(SeqStack *S)
  {if (StackEmpty(S))
Error("Stack underflow");
  else returnS->data[S->top--];
  }

  SDataType StackTop(SeqStack *S)
  {if (StackEmpty(S))
  Error("栈已空\n");
  returnS->data[S->top];
  }

  main()
  {BinTree T;
  char ch1,ch2;
  printf("\n欢迎进入二叉树操作测试程序，请选择：\n");
  ch1='y';
  while(ch1=='y' || ch1=='Y')
 {printf("\nA-------------------------二叉树建立");
 printf("\nB-------------------------先序遍历(非递归)");
 printf("\nC-------------------------退出\n");
  scanf("\n%c",&ch2);
__page_break__
  switch(ch2)
  {case 'A':
  case 'a':printf("按二叉树带空指针的先序次序输入结点:\n");
  CreateBinTree(&T);
  printf("二叉树建立成功\n");break;
  case 'B':
  case 'b':printf("遍历的结果为:\n");
  PreorderN(T);break;
  case 'C':
  case 'c':ch1='n';break;
  default:ch1='n';
  }
  }
  }

  void CreateBinTree(BinTree *T)
  {char ch;
  scanf("\n%c",&ch);
  if (ch=='0') *T=NULL;
  else
{
*T=(BinTNode*)malloc(sizeof(BinTNode));
  (*T)->data=ch;
 CreateBinTree(&(*T)->lchild);
 CreateBinTree(&(*T)->rchild);
  }
}

  void PreorderN(BinTree T)
  {
  SeqStack *S;
  BinTree 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);
 
  Push(S,p->rchild);
  }
  }
  }