二叉树遍历学习

1. 前序遍历。先根节点，再左子树，最后右子树。

// 二叉树前序遍历，递归实现
void PreOrderTraverse(BiTree T)
{
	if (NULL != T)
	{
		std::cout << T->data << " ";
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
}

非递归实现，采用栈的方式。 

// 二叉树前序遍历，非递归实现
void PreOrderTraverseNonRecursive(BiTree T)
{
	// 采用栈形式，压入右子树
	std::stack<BiTree> sBiTree;

	BiTree p = T;
	while ((NULL != p) || !sBiTree.empty())
	{
		// 当前不为空，压入右子树，并输出当前节点
		if (NULL != p)
		{
			sBiTree.push(p->rchild);
			std::cout << p->data << " ";
			p = p->lchild;
		}
		else
		{
			p = sBiTree.top();
			sBiTree.pop();
		}
	}
}

2. 中序遍历。

// 二叉树中序遍历，递归实现
void InOrderTraverse(BiTree T)
{
	if (NULL != T)
	{
		InOrderTraverse(T->lchild);
		std::cout << T->data << " ";
		InOrderTraverse(T->rchild);
	}
}

非递归实现。

// 二叉树中序遍历，非递归实现
void InOrderTraverseNonRecursive(BiTree T)
{
	std::stack<BiTree> sBiTNode;

	BiTree p = T;
	while (( NULL != p) || !sBiTNode.empty())
	{
		if (NULL != p)
		{
			sBiTNode.push(p);
			p = p->lchild;
		}
		else
		{
			p = sBiTNode.top();
			sBiTNode.pop();

			std::cout << p->data << " ";
			p = p->rchild;
		}
	}
}

3. 后序遍历。

// 二叉树后序遍历，递归实现
void PostOrderTraverse(BiTree T)
{
	if (NULL != T)
	{
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
		std::cout << T->data << " ";
	}
}

非递归实现。

// 二叉树后序遍历，非递归实现
void PostOrderTraverseNonRecursive(BiTree T)
{
	std::stack<BiTree> sBiTNode;
	
	BiTree pCur;
	BiTree pPre;

	pPre = NULL;
	sBiTNode.push(T);
	while (!sBiTNode.empty())
	{
		pCur = sBiTNode.top();
		if (((NULL == pCur->lchild) && (NULL == pCur->rchild))
			|| ((NULL != pPre) && ((pPre == pCur->lchild) || (pPre == pCur->rchild))))
		{
			std::cout << pCur->data << " ";
			sBiTNode.pop();
			pPre = pCur;
		}
		else
		{
			if (NULL != pCur->rchild)
			{
				sBiTNode.push(pCur->rchild);
			}
			
			if (NULL != pCur->lchild)
			{
				sBiTNode.push(pCur->lchild);
			}
		}
	}
}

4. 层次遍历，采用队列进行。

// 层次遍历
void levelTreaverse(BiTree T)
{
	std::deque<BiTree> dBiTNode;

	dBiTNode.push_back(T);
	while (!dBiTNode.empty())
	{
		std::cout << dBiTNode[0]->data << " ";
		if (NULL != dBiTNode[0]->lchild)
		{
			dBiTNode.push_back(dBiTNode[0]->lchild);
		}
		if (NULL != dBiTNode[0]->rchild)
		{
			dBiTNode.push_back(dBiTNode[0]->rchild);
		}
		dBiTNode.pop_front();
	}
}