二叉树非递归遍历

1. 非递归前序遍历：遇到一个结点，就访问该结点，并把此结点推入栈中，然后下降去遍历它的左子树。遍历完它的左子树后，从栈顶托出这个结点，并按照它的右链接指示的地址再去遍历该结点的右子树结构。

2. 非递归中序遍历：遇到一个结点，就把它推入栈中，并去遍历它的左子树。遍历完左子树后，从栈顶托出这个结点并访问之，然后按照它的右链接指示的地址再去遍历该结点的右子树。
3. 非递归后序遍历：遇到一个结点，把它推入栈中，遍历它的左子树。遍历结束后，还不能马上访问处于栈顶的该结点，而是要再按照它的右链接结构指示的地址去遍历该结点的右子树。遍历遍右子树后才能从栈顶托出该结点并访问之。另外，需要给栈中的每个元素加上一个特征位，以便当从栈顶托出一个结点时区别是从栈顶元素左边回来的(则要继续遍历右子树)，还是从右边回来的(该结点的左、右子树均已周游)。特征为Left表示已进入该结点的左子树，将从左边回来；特征为Right表示已进入该结点的右子树，将从右边回来。
4. 简洁的非递归前序遍历：遇到一个结点，就访问该结点，并把此结点的非空右结点推入栈中，然后下降去遍历它的左子树。遍历完左子树后，从栈顶托出一个结点，并按照它的右链接指示的地址再去遍历该结点的右子树结构。

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 */