二叉树的前序、中序、后序遍历的算法（递归形式和非递归形式）

//前序遍历非递归算法
#define maxsize 100

typedef struct 
{
	int value;
	Bitree *lchild;
	Bitree *rchild;
}Bitree;

typedef struct
{
	Bitree Elem[maxsize];
	int top;
}SqStack;

void PreOrderUnrec(Bitree *t)
{
	SqStack s;
	StackInit(s);
	Bitree *p = t;

	while (p != NULL || !StackEmpty(s))
	{
		while (p != NULL)				//遍历左子树
		{
			visit(p->data);
			push(s, p);
			p = p->lchild;
		}
		
		if (!StackEmpty(s))				//通过下一次循环中的内嵌while实现右子树遍历  
		{
			p = pop(s);
			p = p->rchild;
		}
	}
}

//中序遍历非递归算法
void InOrderUnrec(Bitree *t)
{
	SqStack s;
	StackInit(s);
	Bitree *p = t;

	while (p != NULL || !StackEmpty(s))
	{
		while (p != NULL)			//遍历左子树
		{
			push(s, p);
			p = p->lchild;
		}
		if (!StackEmpty(s))
		{
			p = pop(s);
			visit(p->data);			//访问根结点
			p = p->rchild;			 //通过下一次循环实现右子树遍历
		}
	}
}

//后序遍历非递归算法
typedef enum{L, R} tagtype;
typedef struct  
{
	Bitree ptr;
	tagtype tag;
}stacknode;

void PostOrderUnrec(Bitree *t)
{
	SqStack s;
	stacknode x;
	StackInit(s);
	Bitree *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;
			visit(p->data);		//tag为R,表示右子树访问完毕，故访问根结点
		}

		if (!StackEmpty(s))
		{
			s.Elem[s.top].tag = R;
			p = s.Elem[s.top].ptr->rchild;
		}
	} while (!StackEmpty(s));
}


//递归算法：
//前序遍历：
void preorder(BTree *T)
{
	//T为二叉树根结点所在链接点的地址
	if(T != NULL)
	{
		visit(T);                 //访问T所指结点
		preorder(T->lchild);      //遍历T所指结点的左子树
		preorder(T->rchild);      //遍历T所指结点的右子树
	}
}

//中序遍历：
void inorder(BTree *T)
{
	//T为二叉树根结点所在链接点的地址
	if(T != NULL)
	{
		inorder(T->lchild);       //遍历T所指结点的左子树
		visit(T);                 //访问T所指结点
		inorder(T->rchild);       //遍历T所指结点的右子树
	}
}
//后序遍历：
void postorder(BTree T)
{
	//T为二叉树根结点所在链接点的地址
	if(T != NULL)
	{
		postorder(T->lchild);       //遍历T所指结点的左子树
		postorder(T->rchild);       //遍历T所指结点的右子树
		visit(T);                 //访问T所指结点
	}
}