二叉树遍历算法-优快云博客

本文链接：https://blog.youkuaiyun.com/sraing/article/details/5542736

定义节点类型如下：

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

广度遍历比较简单：

void layertraverse(btree t) //层次遍历,使用队列q

{

queue <btree*> q;

q.push(root);

while (!q.empty())

{

btree *pNode = &q.front();

visit(pNode->data);

if (pNode->plchild != NULL)

{

q.push(*pNode->plchild);

}

if (pNode->prchild != NULL)

{

q.push(*pNode->prchild);

}

q.pop();

}

return true;

}

之后是深度遍历。

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

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