递归和非递归俩种方法实现二叉树的前序遍历

咱们先来复习下，基础知识。

二叉树结点存储的数据结构：

typedef char datatype;

typedef struct node

{

datatype data;

struct node* lchild,*rchild;

} bintnode;

typedef bintnode* bintree;

bintree root;

1.树的前序遍历即：

按根 左 右 的顺序，依次

前序遍历根结点->前序遍历左子树->前序遍历右子树

前序遍历，递归算法

void preorder(bintree t)

//注，bintree为一指向二叉树根结点的指针

{

if(t)

{

printf("%c",t->data);

preorder(t->lchild);

preorder(t->rchild);

}

}

然后，依葫芦画瓢，得到....

2.中序遍历，递归算法

void preorder(bintree t)

{

if(t)

{

inorder(t->lchild);

printf("%c",t->data);

inorder(t->rchild);

}

}

3.后序遍历，递归算法

void preorder(bintree t)

{

if(t)

{

postorder(t->lchild);

postorder(t->rchild);

printf("%c",t->data);

}

}

二叉树的创建方法，

void createbintree(bintree* t)

{

char ch;

if( (ch=getchar())==' ')

*t=NULL;

else

{

*t=(bintnode*) malloc(sizeof(bintnode));

(*t)->data=ch;

createbintree(&(*t)->lchild);

createbintree(&(*t)->rchild);

}

}

接下来，

咱们在讨论二叉树遍历算法的非递归实现之前，

先看一个顺序栈的定义及其部分操作的实现

typedef struct stack

{

bintree data[100];

int tag[100];

int top;

}seqstack;

void push(seqstack* s,bintree t)

{

s->data[s->top]=t;

s->top++;

}

bintree pop(seqstack* s) //出栈

{

if(s->top!=0)

{

s->top--;

return (s->data[s->top]);

}

else

return NULL;

}

好了，现在，我们可以看二叉树前序遍历的非递归实现了。

按照二叉树前序遍历的定义，无论是访问整棵树还是其子树，均应该遵循先访问根结点，

然后访问根结点的左子树，最后访问根结点的右子树的。

因为对于一棵树（子树）t,如果t非空，访问完t的根结点值后，就应该进入t的左子树，

但此时必须将t保存起来，以便访问完其左子树后，进入其右子树的访问。

yeah，就是这个意思。:）...

即在t处设置一个回溯点，并将该回溯点进栈保存。

在整个二叉树前序遍历的过程中，程序始终要做的工作分成俩个部分：

1.当前正在处理的树（子树）

2.保存在栈中等待处理的部分。

//注：当栈中元素位于栈顶即将出栈时，意味着其根结点和左子树已访问完成，

//出栈后，进入其右子树进行访问，

//前序遍历，非递归实现

void preorderT(bintree t)

{

seqstack s;

s.top=0;

while( (t)||(s.top!=0) ) //当前处理的子树不为空或栈不为空

{

while(t) //子树不为空

{

printf("%c",t->data); //1.先访问根结点

push(&s,t); //2.访问左子树之前，记得先把根结点进栈保存

t=t->lchild; //3.然后才访问左子树，

}

if(s.top>0) //栈不为空

{

t.pop(&s); //4.pop根结点

t=t->rchild; //5.访问右子树

}

}

}

//中序遍历，非递归实现，

void inorderT(bintree t)

{

seqstack s;

s.top=0;

while( (t)||(s.top!=0) ) //当前处理的子树不为空或栈不为空

{

while(t) //子树不为空

{

push(&s,t); //1.访问左子树之前，记得先把根结点push进栈

t=t->lchild; //2.访问左子树

}

if(s.top!=0) //栈不为空

{

t.pop(&s); //3.pop根结点(访问完左子树后)

printf("%c",t->data); //4.访问根结点 (把先前保存的t给拿出来，要用了..)

t=t->rchild; //5.访问右子树

}

}

}

//后序遍历，非递归实现

后序遍历的非递归算法，稍微复杂点。请看，

按照二叉树后序遍历的定义，无论是访问整棵树还是起子树，

均应该遵循先访问根结点左子树，然后访问根结点的右子树，最后访问根结点。

值得注意的是，当一个元素位于栈顶即将处理的是，其左子树的访问一定完成，

如果其右子树不为空，接下来应该进入其右子树尽情访问。

//注意了，

但此时该栈顶元素时不能出栈的，因为它作为根结点，其本身的值还未被访问。

只有等到其右子树也访问完成后，该栈顶元素才能出栈，并输出它的值。

因此，在二叉树后序遍历的算法中，必须使用seqstack类型的数组tag，

其每个元素取值为0或1，用于标识栈中每个元素的状态。

1.当一个元素刚进栈时，其对应的tag值置为0；

2.当它位于栈顶即将被处理时，其tag值为0.意味着应该访问其右子树。

于是将右子树作为当前处理的对象，此时该栈顶元素仍应该保留在栈中。

并将其对应的tag值改为1.

3.当其右子树访问完成后，该元素又一次位于栈顶，而此时其tag值为1，

意味着其右子树已访问完成，接下来，应该直接访问的就是它，将其出栈。

void postorderT(bintree t)

{

seqstack s;

s.top=0;

while( (t)||(s.top!=0) )

{

while(t)

{

s.data[s.top]=t;

s.tag[s.top]=0; //tag置为0

s.top++;

t=t->lchild; //访问左子树

}

while( (s.top>0)&&(s.tag[s.top-1]==1) )

{

s.top--;

t=s.data[s.top];

printf("%c",t->data);

}

if(s.top>0)

{

t=s.data[s.top-1];

s.tag[s.top-1]=1;

t=t->rchild;

}

else

t=NULL;

}

}