二叉树的前序非递归遍历

二叉树的前序非递归遍历

前面学习过二叉树的前序遍历，使用递归的方式。简单回顾一下：

Status PerOrder(BiTree T) {
	//前序遍历二叉树
	if (T != NULL) {
		Visit(T);
		PerOrder(T->lchild);
		PerOrder(T->rchild);
	}
	return OK;
}

接下来用非递归的方式实现二叉树的前序遍历。我们可以利用栈来辅助实现该功能。

定义二叉树的结构体：

typedef struct BiTree{//定义二叉树
	char data;
	struct BiTree* lchild;
	struct BiTree* rchild;
}BiTNode,* BiTree;

定义辅助栈的结构体。注意栈中应存放的数据类型：

typedef struct {//定义栈
	BiTree base;
	BiTree top;
	int stacksize;
}SqStack;

在遍历操作中，我们需要用到栈的操作有初始化、出栈、入栈、判空。具体代码见附录。

算法思路

利用前序遍历的性质，访问顺序应该是“根，左，右”。我们首先让根结点入栈，每次入栈一个元素，就访问他。一直循环直到到达二叉树最左边的结点，也就是将遍历指针指向最左边的结点。之后出栈，每出栈一个元素，将遍历指针指向该元素的右子树，如果存在，进行与之前一样的操作，循环找到该子树当中最左端的结点。若不存在右子树，继续出栈一个元素，找该元素的右子树，以此类推。

Status PreOrderTraverse(BiTree T) {
	SqStack S;		
	InitStack(&S);	//初始化一个栈
	BiTree P = T;	//遍历指针
	BiTree Q = T;
	while (P || !StackEmpty(S)) {	//若P不为空或者栈不空则循环
		if (P) {
			Visit(P);				//进栈就访问
			Push(&S, *P);			//入栈
			P = P->lchild;			//向左走到尽头
		}
		else {
			Pop(&S, Q);		//出栈
			P = Q;
			P = P->rchild;	//访问出栈元素的右孩子
		}
	}
	return OK;
}

通过代码，可以自己画图理解，其实逻辑并不是很复杂。

相对更加省事的一种方式

上面介绍的方式需要另外定义一个栈，并将栈的基本操作写出来。还有另外一种方法，直接在非递归遍历函数中，构造一个数组，实现栈的功能，如下所示：

Status PreOrderTraverse(BiTree T){
	if (T != NULL)							//根节点是否为空
	{
		BiTNode* Stack[STACK_INIT_SIZE];
		int top = -1;						//创建栈
		BiTNode* p = NULL;					//遍历指针
		Stack[++top] = T;					//节点入栈
		while (top != -1)					//栈不空时循环
		{
			p = Stack[top--];					//出栈一个元素
			printf("%c", p->data);				//访问
			if (p->rchild != NULL)				//右孩子不为空就入栈
				Stack[++top] = p->rchild;
			if (p->lchild != NULL)				//左孩子不为空就入栈
				Stack[++top] = p->lchild;
		}
	}
	return OK;
}

两种方式均可以测试通过。

附录：代码

用两种代码格式做到前序非递归遍历二叉树，构建二叉树时利用前序序列构建，然后输出前序遍历结果。

#include<stdio.h>
#include<stdlib.h>
#define TRUE			1
#define FALSE			0
#define OK				1
#define ERROR			0
#define OVERFLOW		-1
#define STACK_INIT_SIZE 100
typedef struct BiTree{//定义二叉树
	char data;
	struct BiTree* lchild;
	struct BiTree* rchild;
}BiTNode,* BiTree;
typedef struct {//定义栈
	BiTree base;
	BiTree top;
	int stacksize;
}SqStack;
typedef int Status;

Status InitStack(SqStack* S) {//构造一个空栈
	(*S).base = (BiTNode*)malloc(STACK_INIT_SIZE * sizeof(BiTNode));
	if (!(*S).base)exit(OVERFLOW);
	(*S).top = (*S).base;
	(*S).stacksize = STACK_INIT_SIZE;
	return OK;
}
Status GetTop(SqStack S, BiTree e) {//得到栈顶元素
	if (S.top == S.base)return ERROR;
	*e = *(S.top - 1);
	return OK;
}
Status Push(SqStack* S, BiTNode e) {//出栈
	*S->top++ = e;
	return OK;
}
Status Pop(SqStack* S, BiTree e) {//入栈
	if (S->base == S->top)return ERROR;
	*e = *--S->top;
	return OK;
}
Status StackEmpty(SqStack S) {//判空
	if (S.base == S.top)return TRUE;
	else return FALSE;
}
Status CreatBiTree(BiTree* root) {//构造二叉树
	char c;
	scanf_s("%c", &c, sizeof(c));
	if (c == '#')*root = NULL;
	else {
		*root = (BiTree)malloc(sizeof(BiTNode));
		if (!(*root)) { printf("\n内存分配失败\n");exit(OVERFLOW); }
		(*root)->data = c;
		CreatBiTree(&(*root)->lchild);
		CreatBiTree(&(*root)->rchild);
	}
	return OK;
}
Status PreOrderTraverse_1(BiTree T){
	if (T != NULL)							//根节点是否为空
	{
		BiTNode* Stack[STACK_INIT_SIZE];
		int top = -1;						//创建栈
		BiTNode* p = NULL;					//遍历指针
		Stack[++top] = T;					//节点入栈
		while (top != -1)					//栈不空时循环
		{
			p = Stack[top--];					//出栈一个元素
			printf("%c", p->data);				//访问
			if (p->rchild != NULL)				//右孩子不为空就入栈
				Stack[++top] = p->rchild;
			if (p->lchild != NULL)				//左孩子不为空就入栈
				Stack[++top] = p->lchild;
		}
	}
	return OK;
}
Status PreOrderTraverse_2(BiTree T) {
	SqStack S;		
	InitStack(&S);	//初始化一个栈
	BiTree P = T;	//遍历指针
	BiTree Q = T;
	while (P || !StackEmpty(S)) {	//若P不为空或者栈不空则循环
		if (P) {
			Visit(P);				//进栈就访问
			Push(&S, *P);			//入栈
			P = P->lchild;			//向左走到尽头
		}
		else {
			Pop(&S, Q);		//出栈
			P = Q;
			P = P->rchild;	//访问出栈元素的右孩子
		}
	}
	return OK;
}
Status Visit(BiTree T) {
	printf("%c", T->data);
	return OK;
}


void main() {
	BiTree Tree;
	CreatBiTree(&Tree);
	PreOrderTraverse_1(Tree);
	printf("\n");
	PreOrderTraverse_2(Tree);
}