二叉树的三种遍历

树的遍历有三种，前中后序遍历。以下分别用递归和非递归实现遍历。

树的结构定义：

typedef  struct BTNode

{

ElemType x;

BTNode * leftchild;

BTNode * rightchild;

}

一丶递归遍历

前序递归遍历

void PreOrder(BTNode * p)
{
    if(p != NULL) 

	{
    	cout<<p->data<<" ";

    	PreOrder(p->leftchild);
    	PreOrder(p->rightchild);

	}
}

中序递归遍历

void InOrder(BTNode * p)
{
    if(p!=NULL)
    {
        InOrder(p->leftchild);
	cout<<p->data<<" ";
	InOrder(p->rightchild);
    }
}

后序递归遍历

void PastOrder(BTNode * p)
{
	if(p != NULL)
	{
		PastOrder(p->leftchild);
		PastOrder(p->rightchild);
		cout<<p->data<<" ";
	}
}

二丶非递归遍历

前序非递归遍历

相对递归遍历来说，非递归遍历比较不好写一些。这里我通过栈来实现非递归遍历树。当树不为空且栈不为空时，沿左孩子一路输出数据和压栈，到达最左下的子节点。若栈不为空时说明数据还没有处理完毕，则顶部数据出栈，再到右孩子处。画图比较容易理解。还有一种想法，从右往左压栈。代码实现如下。

void NicePreOrder(BTNode *ptr)
{
	if(ptr == NULL ) return ;
	stack<BTNode *> s;
	while(ptr != NULL || !s.empty())
	{
		while(ptr != NULL)
		{
			cout<<ptr->data<<" ";
			s.push(ptr);
			ptr=ptr->leftchild;
		}
		if(!s.empty())
		{
			ptr=s.top();
			s.pop();
			ptr=ptr->rightchild;
		}
	}

			cout<<endl;

}

void NicePreOrder(BTNode *ptr)
{
	if(ptr == NULL) return ;
	stack<BTNode *> st;
	st.push(ptr);
	while(!st.empty())
	{
		ptr = st.top();st.pop();
		cout<<ptr->data<<" ";
		if(ptr->rightchild != NULL)
		{
			st.push(ptr->rightchild);
		}
		if(ptr->leftchild != NULL)
		{
			st.push(ptr->leftchild);
		}
	}
	cout<<endl;
}

中序非递归遍历

中序的大致思路和前序遍历差不多。

void NiceInOrder(BTNode *ptr)
{
	if(ptr == NULL) return ;
	stack<BTNode *> st;
	while(ptr != NULL || !st.empty())//
	{
		while(ptr != NULL)
		{
			st.push(ptr);
			ptr = ptr->leftchild;
		}
		ptr = st.top();
		st.pop();
		cout<<ptr->data<<" ";
		ptr =ptr->rightchild;
	}
	cout<<endl;
}

后序非递归遍历

后序是这三种相对难一点的，因为中间的结点要最后再出栈。在这里我设置了一个标记点用来保存前一次访问过的结点。当发现右孩子结点访问过时，结点输出数据并弹出栈。

void NicePastOrder(BTNode *ptr)
{
	if(ptr == NULL) return ;
	BTNode *tag = NULL;
	stack<BTNode *> st;
	while(ptr != NULL || !st.empty())//
	{
		while(ptr != NULL)
		{
			st.push(ptr);
			ptr = ptr->leftchild;
		}
		ptr = st.top();
		st.pop();
		if(ptr->rightchild == NULL || ptr->rightchild == tag)
		{
			cout<<ptr->data<<" ";
			tag = ptr;
			ptr = NULL;
		}else
		{
			st.push(ptr);
			ptr =ptr->rightchild;
		}
	}
	cout<<endl;
}

除了用一个变量来确定是否经过多次访问，还有什么方法呢？下面用另一种方法实现。定义一个类，内置一个计数器，确定这个结点是否经过多次出栈。

结构体如下。

struct StkNode
{
	BTNode *pnode;
	int     popnum;
public:
	StkNode(BTNode *p=NULL):pnode(p),popnum(0) {}
};

只对于中后序遍历使用（因为前序的中间结点直接就出来了）。

代码实现如下。

void StkPastOrder(BTNode *ptr)
{
	if(ptr == NULL) return ;
	stack<StkNode> st;
	st.push(StkNode(ptr));
	while(!st.empty())
	{
		StkNode node = st.top(); st.pop();
		if(++node.popnum == 3)
		{
			cout<<node.pnode->data<<" ";
		}else
		{
			st.push(node);
			if(node.popnum == 1 && node.pnode->leftchild != NULL)
			{
				st.push(StkNode(node.pnode->leftchild));
			}else if(node.popnum == 2 && node.pnode->rightchild != NULL)
			{
				st.push(StkNode(node.pnode->rightchild));
			}
		}
	}
	cout<<endl;
}

void StkInOrder(BTNode *ptr)
{
	if(ptr == NULL) return ;
	stack<StkNode> st;
	st.push(StkNode(ptr));
	while(!st.empty())
	{
		StkNode node = st.top(); st.pop();
		if(++node.popnum == 2)
		{
			if(node.pnode->rightchild != NULL)
			{
				st.push(StkNode(node.pnode->rightchild));
			}
			cout<<node.pnode->data<<" ";
		}else
		{
			st.push(node);
			if(node.popnum == 1 && node.pnode->leftchild != NULL)
			{
				st.push(StkNode(node.pnode->leftchild));
			}
		}
	}
	cout<<endl;
}