二叉树遍历非递归算法

给大家一个效率较高的后序遍历非递归算法（c语言编写，本算法不需要改变二叉树的结点结构）：

typedef struct node  { /*二叉树的结点存储类型为链式*/
    char data;
    struct node *lchild,*rchild;
}node,*btree;

void backordertraverse(btree t)  {  /*用栈标记法（本人喜欢这样叫）*/
    btree* stack[max_size];
    int tag[max_size],top=0;
    do  {
        while(t)  {  /*由于非地址调用，所以不会改变数根t*/
            top++;
            stack[top]=t;
            tag[top]=0;
            t=t->lchild;
        }
        if(top>0)  {  /*栈不空,为了简洁下面采用了逗号表达式*/
            if(tag[top]==1)  printf("%c ",stack[top].data),top--;
            else  t=stack[top],t=t->rchild,tag[top]=1;
           
         }
    }while(top>0); /*栈不空*/
}
=====================================================================
本贴给出二叉树先序、中序、后序三种遍历的非递归算法，此三个算法可视为标准算法。
1.先序遍历非递归算法
#define maxsize 100
typedef struct
{
    Bitree Elem[maxsize];
    int top;
}SqStack;

void PreOrderUnrec(Bitree t)
{
    SqStack s;
    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
{
    Bitree Elem[maxsize];
    int top;
}SqStack;

void InOrderUnrec(Bitree t)
{
    SqStack s;
    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
{
    Bitree ptr;
    tagtype tag;
}stacknode;

typedef struct
{
    stacknode Elem[maxsize];
    int top;
}SqStack;

void PostOrderUnrec(Bitree t)
{
    SqStack s;
    stacknode x;
    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

==================================================================================

一个完整的前序遍历非递归
*sy32.c*/
#include <stdio.h>
#include <stdlib.h>
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 /*假定预分配的栈空间最多为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) /*判栈空*/
{return S->top==-1;
}
int StackFull(SeqStack *S) /*判栈满*/
{return S->top==StackSize-1;
}
void Push(SeqStack *S, SDataType x) /*进栈*/
{if(StackFull(S))
Error("栈已满/n"); /*上溢退出*/
else S->data[++S->top]=x; /*栈顶指针加1后将x进栈*/
}
SDataType Pop(SeqStack *S) /*出栈*/
{if (StackEmpty(S))
Error("Stack underflow"); /*下溢退出*/
else return S->data[S->top--]; /*栈顶指针返回后将栈顶指针减1*/
}
SDataType StackTop(SeqStack *S) /*取栈顶元素*/
{if (StackEmpty(S))
Error("栈已空/n");
return S->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);
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)
{/*先序遍历二叉树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);
/* printf("%3c",p->data); */
Push(S,p->rchild);
}
}
}/*PreorderN */