C++版本二叉树的遍历原理讲解及代码实现

1.广度优先

/*
* 节点 
*/
struct Node
{
	int data;//节点值
	Node* left;//左节点
	Node* right;//右节点
};

/*!
* \brief 广度优先搜索算法
* \param pTree : Node * 二叉树
* \returns void :
* \throws <exception class>
* \remarks
* \see
*/
void BreadthFirstSearch(Node* pTree)
{
	/*
				   A
				 /   \
			   B       C
			  / \     / \
			 D   E   F   G

	广度优先：A B C D E F G
	*/

	/*
	算法逻辑：
		1.遍历根节点
		2.遍历左子树
		3.遍历右子树

		借助队列先进先出的顺序，先将左子树入队，再对右子树入队
	*/

	if (pTree == nullptr)
		return;

	queue<Node*>queueNode;
	queueNode.push(pTree);
	Node* pNode;
	while (!queueNode.empty())
	{
		pNode = queueNode.front;
		queueNode.pop();
		std::cout << pNode->data << std::endl;
		if (pNode->left != nullptr)
			queueNode.push(pNode->left);
		if (pNode->right != nullptr)
			queueNode.push(pNode->right);
	}
}

2.深度优先

/*
* 节点 
*/
struct Node
{
	int data;//节点值
	Node* left;//左节点
	Node* right;//右节点
};

/*!
* \brief 深度优先搜索算法
* \param pTree : Node * 二叉树
* \returns void : 
* \throws <exception class>
* \remarks 
* \see 
*/
void DepthFirstSearch(Node* pTree)
{
	/*
	     A              
				 /   \
			   B       C
			  / \     / \
			 D   E   F   G
	
	深度优先：A B D E C F G	
	*/

	/*
	算法逻辑：
		1.遍历根节点
		2.遍历左子树
		3.遍历右子树

		借助栈先进后出的顺序，先将右子树压栈，再对左子树压栈
	*/

	if (pTree == nullptr)
		return;

	stack<Node*>stackNode;
	stackNode.push(pTree);
	Node* pNode;
	while (!stackNode.empty())
	{
		pNode = stackNode.top();
		std::cout << pNode->data << std::endl;
		stackNode.pop();
		if (pNode->right != nullptr)
			stackNode.push(pNode->right);
		if (pNode->left != nullptr)
			stackNode.push(pNode->left);		
	}
}

3.遍历（先/中/后序）

3.1递归

/*
* 节点 
*/
struct Node
{
	int data;//节点值
	Node* left;//左节点
	Node* right;//右节点
};


#include <iostream>
#include <stack>

/*!
* \brief 递归方式实现二叉树（先/中/后序）遍历
* \param pHead : Node * 节点
* \returns void : 
* \throws <exception class>
* \remarks 
* \see 
*/
void Traversal(Node* pHead)
{
	if (pHead == nullptr)
		return;

	//
	//前序遍历（根 左 右）
	std::cout << pHead->data << std::endl;
	Traversal(pHead->left);
	Traversal(pHead->right);

	//
	//中序遍历（左 根 右）
	Traversal(pHead->left);
	std::cout << pHead->data << std::endl;
	Traversal(pHead->right);

	//
	//后序遍历（左 右 根）
	Traversal(pHead->left);
	Traversal(pHead->right);
	std::cout << pHead->data << std::endl;
}

3.2非递归

/*
* 节点 
*/
struct Node
{
	int data;//节点值
	Node* left;//左节点
	Node* right;//右节点
};


#include <iostream>
#include <stack>
/*!
* \brief 非递归方式实现二叉树先序遍历
* \param pHead : Node * 节点
* \returns void :
* \throws <exception class>
* \remarks 前序遍历（根 左 右）
* \see
*/
void TraversalPre(Node* pHead)
{
	if (pHead == nullptr)
		return;

	std::stack<Node*>stackNode;
	stackNode.push(pHead);
	Node* pNode = pHead;
	while (!stackNode.empty())
	{
		pNode = stackNode.top();
		std::cout << pNode->data << std::endl;
		stackNode.pop();

		if (pNode->right != nullptr)
			stackNode.push(pNode->right);

		if (pNode->left != nullptr)
			stackNode.push(pNode->left);
	}
}


/*!
* \brief 非递归方式实现二叉树中序遍历
* \param pHead : Node * 节点
* \returns void :
* \throws <exception class>
* \remarks 中序遍历（左 根 右）
* \see
*/
void TraversalIn(Node* pHead)
{
	if (pHead == nullptr)
		return;

	std::stack<Node*>stackNode;
	while (!stackNode.empty() || pHead != nullptr)
	{
		if (pHead != nullptr)
		{
			stackNode.push(pHead);
			pHead = pHead->left;
		}
		else
		{
			pHead = stackNode.top();
			std::cout << pHead->data << std::endl;
			stackNode.pop();
			pHead = pHead->right;
		}
	}
}

/*!
* \brief 非递归方式实现二叉树后序遍历
* \param pHead : Node * 节点
* \returns void :
* \throws <exception class>
* \remarks 后序遍历（左 右 根）
* \see
*/
void TraversalPos(Node* pHead)
{
	if (pHead == nullptr)
		return;

	std::stack<Node*>stackNode1;
	std::stack<Node*>stackNode2;
	Node* pNode;

	stackNode1.push(pHead);

	while (!stackNode1.empty())
	{
		pNode = stackNode1.top();
		stackNode2.push(pNode);
		stackNode1.pop();

		if (pNode->left != nullptr)
			stackNode1.push(pNode->left);

		if (pNode->right != nullptr)
			stackNode1.push(pNode->right);
	}

	while (!stackNode2.empty())
	{
		std::cout << stackNode2.top()->data << std::endl;
		stackNode2.pop();
	}
}