【C++】二叉树遍历--递归与非递归实现

1、二叉树前序遍历

前序遍历主要顺序是先遍历根节点，再遍历左节点，最后遍历右结点

1.1非递归实现

void PreOrder_Nor1()//循环
{
	cout << "PreOrder_Nor: ";
	_PreOrder_Nor1(_pRoot);
	cout << endl;
}
void _PreOrder_Nor1(Node* pRoot)//先将左子树全部访问并入栈，再依次出栈访问右子树
{
	if (pRoot == NULL)
		return;
	stack<Node*> s;
	Node* pCur = pRoot;
	Node* pRev = NULL;
	while (pCur != NULL || !s.empty())
	{
		while (pCur != NULL)
		{
			s.push(pCur);
			cout << pCur->_data << " ";
			pCur = pCur->_pLeft;
		}
		pCur = s.top();
		if (pCur->_pRight == NULL || pRev == pCur->_pRight)
		{
			pRev = pCur;
			s.pop();
			pCur = NULL;
		}
		else
		{
			pCur = pCur->_pRight;
		}
	}
}

1.2递归实现

void PreOrder()
{
	cout << "PreOrder:" ;
	_PreOrder(_pRoot);
	cout << endl;
}

具体实现方法：

void _PreOrder(Node* pRoot)
	{
		if(pRoot)
		{
			cout << pRoot->_value << " ";
			_PreOrder(pRoot->_pLeft);
			_PreOrder(pRoot->_pRight);
		}
	}

2、二叉树中序遍历

中序遍历主要顺序是先遍历左节点，再遍历根节点，最后遍历右结点

2.1非递归实现

void InOrder_Nor()//中序遍历--循环
{
	cout << "InOrder_Nor: ";
	_InOrder_Nor(_pRoot);
	cout << endl;
}
void  _InOrder_Nor(Node* pRoot)//中序遍历---循环
{
	if (pRoot == NULL)
		return;
	stack<Node*> s;
	Node* pCur = pRoot;
	while (pCur != NULL || !s.empty())
	{
		while (pCur != NULL)//找到最左的节点
		{
			s.push(pCur);
			pCur = pCur->_pLeft;
		}
		pCur = s.top();
		cout << pCur->_data << " ";
		s.pop();

		//pCur = pCur->_pRight; //不区分的时候

		while (pCur->_pRight == NULL && !s.empty())//当右子树的节点为NULL时，不断出栈
		{
			pCur = s.top();
			cout << pCur->_data << " ";
			s.pop();
		}
		pCur = pCur->_pRight;
	}
}

2.2递归实现

void InOrder()
{
	cout << "InOrder:" ;
	_InOrder(_pRoot);
	cout << endl;
}

具体实现方法：

void _InOrder(Node* pRoot)
{
	if (pRoot)
	{
		_InOrder(pRoot->_pLeft);
		cout << pRoot->_value << " ";
		_InOrder(pRoot->_pRight);
	}
}

3、二叉树后序遍历

中序遍历主要顺序是先遍历左节点，再遍历右结点，最后遍历根节点

3.1非递归实现

void PostOrder_Nor()//后序遍历--循环
{
	cout << "PostOrder_Nor: ";
	_PostOrder_Nor(_pRoot);
	cout << endl;
}
void _PostOrder_Nor(Node* pRoot)//后续遍历---循环
{
	if (pRoot == NULL)
		return;
	stack<Node*> s;
	Node* pCur = _pRoot;
	Node* pRev = NULL;//标记该节点是否访问过
	while (!s.empty() || pCur != NULL)
	{
		while (pCur != NULL)
		{
			s.push(pCur);
			pCur = pCur->_pLeft;
		}
		pCur = s.top();
		if (pCur->_pRight == NULL || pRev == pCur->_pRight)
		{
			cout << pCur->_data << " ";
			pRev = pCur;
			s.pop();
			pCur = NULL;
		}
		else
		{
			pCur = pCur->_pRight;
		}
	}
}

3.2递归实现

void PostOrder()
{
	cout << "PostOrder:" ;
	_PostOrder(_pRoot);
	cout << endl;
}

具体实现方法：

void _PostOrder(Node* pRoot)
{
	if (pRoot)
	{
		_PostOrder(pRoot->_pLeft);
		_PostOrder(pRoot->_pRight);
		cout << pRoot->_value << " ";
	}
}

4、二叉树层序遍历

void _LevelOrder(Node* pRoot)//层序遍历
{
	if (pRoot != NULL)
	{
		queue<Node*> q;
		q.push(pRoot);

		Node*pCur = NULL;
		while (!q.empty())
		{
			pCur = q.front();
			cout << pCur->_data << " ";
			if (pCur->_pLeft)
				q.push(pCur->_pLeft);
			if (pCur->_pRight)
				q.push(pCur->_pRight);
			q.pop();
		}
	}
}