二叉树非递归遍历_二叉树的非递归遍历-CSDN博客

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