二叉树的遍历-递归和非递归算法

遍历二叉树的三种方法：


前序：根节点->左子树->右子树


中序：左子树->根节点->右子树


后序：左子树->右子树->根节点


 


非递归算法中序遍历二叉树，设S为一个栈，p为指向根节点的指针，处理过程如下：


1）当p非空时，压栈p指针，并将p指向该节点的左子树。


2）当p为空时，弹出栈顶元素，显示节点元素，并将p指向该节点的右子树。


3）重复步骤1）和2），直到栈空且p空。


C语言代码如下：


// 二叉树节点
typedef struct Bitree
{
char data;
struct Bitree *lchild, *rchild;
}Bitree;


// 新节点
Bitree *new(char data)
{
Bitree *a = (Bitree *)malloc(sizeof(Bitree));
a->data = data;
a->lchild = NULL;
a->rchild = NULL;
return a;
}


// 中序遍历二叉树的递归算法
void inorder(Bitree *t)
{
if (t)
{
inorder(t->lchild);
printf("%c ", t->data);
inorder(t->rchild);
}
}


// 前序遍历二叉树的递归算法
void preorder(Bitree *t)
{
if (t)
{
printf("%c ", t->data);
preorder(t->lchild);
preorder(t->rchild);
}
}


// 后序遍历二叉树的递归算法
void postorder(Bitree *t)
{
if (t)
{
postorder(t->lchild);
postorder(t->rchild);
printf("%c ", t->data);
}
}




// 前序遍历二叉树的非递归算法
void preorder2(Bitree *t)
{
Bitree *s[32];// s是指针数组，数组中元素为二叉树节点的指针
int top = -1;
while (t!=NULL || top != -1)
{
// 压栈直到左子树为空
while (t != NULL)
{
printf("%c ", t->data);
s[++top] = t;
t = t->lchild;
}
if (top != -1)
{
t = s[top--]; // 出栈
t = t->rchild;// 指向该节点的右孩子，回到while循环压栈
}
}
}


// 中序遍历二叉树的非递归算法
void inorder2(Bitree *t)
{
Bitree *s[32];// s是指针数组，数组中元素为二叉树节点的指针
int top = -1;
while (t!=NULL || top != -1)
{
// 压栈直到左子树为空
while (t != NULL)
{
s[++top] = t;
t = t->lchild;
}
if (top != -1)
{
t = s[top--]; // 出栈
printf("%c ", t->data);
t = t->rchild;// 指向该节点的右孩子，回到while循环压栈
}
}
}


// 后序遍历二叉树的非递归算法
void postorder2(Bitree *t)
{
Bitree *s[32];// s是指针数组，数组中元素为二叉树节点的指针
int tag[32]; // s中相对位置的元素的tag: 0或1
int top = -1;
while (t!=NULL || top != -1)
{
// 压栈直到左子树为空
while (t != NULL)
{
s[++top] = t;
tag[top] = 0;
t = t->lchild;
}
// 当栈非空，并且栈顶元素tag为1时，出栈并访问
while (top!=-1 && tag[top]==1)
{
printf("%c ", s[top--]->data);
}
// 当栈非空时，将栈顶tag置1，并指向栈顶元素的右孩子
if (top != -1)
{
tag[top] = 1;
t = s[top]->rchild;
}
}
}


int main()
{
// 申请空间构造一棵二叉树
Bitree *a = new('A');
Bitree *b = new('B');
Bitree *c = new('C');
Bitree *d = new('D');
Bitree *e = new('E');
Bitree *f = new('F');
a->lchild = b;
a->rchild = c;
b->lchild = d;
b->rchild = e;
c->rchild = f;


// 递归算法
printf("preorder: ");
preorder(a);
printf("/n");

printf("inorder: ");
inorder(a);
printf("/n");

printf("postorder: ");
postorder(a);
printf("/n");

printf("/n");

// 非递归算法
printf("preorder2: ");
preorder2(a);
printf("/n");

printf("inorder2: ");
inorder2(a);
printf("/n");

printf("postorder2: ");
postorder2(a);
printf("/n");

free(a); free(b); free(c); free(d); free(e); free(f);

return 0;
}