二叉树的三种遍历（前序，中序，后序）

最新推荐文章于 2020-10-20 20:53:49 发布

chenmiao0924

最新推荐文章于 2020-10-20 20:53:49 发布

阅读量896

点赞数

CC 4.0 BY-SA版权

分类专栏： c++ 数据结构文章标签：二叉树遍历前序中序后序

本文链接：https://blog.csdn.net/ChenMiao0924/article/details/71374878

c++ 同时被 2 个专栏收录

13 篇文章

订阅专栏

数据结构

10 篇文章

订阅专栏

本文详细介绍了二叉树的三种遍历方法：前序遍历（根节点->左子树->右子树）、中序遍历（左子树->根节点->右子树）和后序遍历（左子树->右子树->根节点），并探讨了它们的应用场景和实现技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

首先，创建二叉树

//-------------孩子表示法---------------

//节点
template <typename T>
struct BinaryTreeNode
{
	BinaryTreeNode(const T& value):_value(value),_pLeft(NULL),_pRight(NULL)
	{
	}
        T _value;
        BinaryTreeNode<T>* _pLeft;//左孩子
        BinaryTreeNode<T>* _pRight;//右孩子
};

//二叉树
template <class T>
class BinaryTree
{

	typedef BinaryTreeNode<T> Node;
public:
	BinaryTree():_pRoot(NULL)
	{
	}
	
	BinaryTree(const T* arr,size_t size,const T& invalid)
	{
	  size_t index=0;
	  _CreateBinaryTree(_pRoot,arr,size,index,invalid);
	}

private:
	//创建树
	void _CreateBinaryTree(Node*& pRoot,const T* arr,size_t size,size_t& index,const T& invalid)
	{
	    if(index<size && invalid!=arr[index])
		{
		   //根节点
			pRoot =new Node(arr[index]);
			//左子树
			_CreateBinaryTree(pRoot->_pLeft,arr,size,++index,invalid);
			//右子树
			_CreateBinaryTree(pRoot->_pRight,arr,size,++index,invalid);
		}
	}

}

先序遍历：先访问根节点，接着访问左子树，再访问右子树

以下用两种方法实现：

第一种：递归实现

 /*先序遍历（根节点--左子树---右子树）*/

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

将上面的函数封装在下面的函数中

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

第二种：循环实现

/*思路：根入栈--访问栈顶，出栈--右入栈--左入栈*/
public:
	void PreOrder_Not()
	{
	   if(NULL ==_pRoot)
	     return ;
	  stack<Node*> s;
	  s.push(_pRoot);
	  while(!s.empty())
	  {
	   Node* pTop=s.top();
	   cout<<pTop->_value<<" ";
	   s.pop();
	   if(pTop->_pRight)
		   s.push(pTop->_pRight);
	   if(pTop->_pLeft)
		   s.push(pTop->_pLeft);
	  }

		cout<<endl;
	}

中序遍历：访问顺序：左子树---根节点-----右子树
第一种：递归实现

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

/*中序遍历（左子树--根节点---右子树）*/
private:
	void _InOrder(Node* pRoot)
	{
		if(pRoot)
		{
		  _InOrder(pRoot->_pLeft);
		  cout<<pRoot->_value<<" ";
		  _InOrder(pRoot->_pRight);
		}
		
	}

第二种：循环实现

public：

        void InOrder_Nor()
	{
	  stack<Node*> s;
		Node* pCur=_pRoot;
		while(pCur||!s.empty())
		{
			//找到最左边的节点，记录做过的节点
	       while(pCur)
		   {
		     s.push(pCur);
			 pCur=pCur->_pLeft;
		   }
		   //访问节点
		   pCur=s.top();
		   cout<<pCur->_value<<" ";
		   s.pop();

		   //访问右子树
		   pCur=pCur->_pRight;
		}
     cout<<endl;
	}

后序遍历：访问顺序：左子树---右子树----根节点

第一种：递归实现

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

/*后序遍历（左子树---右子树----根节点）*/
private:
	void _PostOrder(Node* pRoot)
	{
	  if(pRoot)
	  {
		  _PostOrder(pRoot->_pLeft);
		  _PostOrder(pRoot->_pRight);
		  cout<<pRoot->_value<<" ";
	  }
	
	}

第二种：循环实现

public:
       void PostOrder()
	{
		_PostOrder(_pRoot);
		cout<<endl;
	}
	//非递归：
	void PostOrder_Nor()
	{
	 if(NULL == _pRoot)
		 return ;
	 stack<Node*> s;
	 Node* pCur=_pRoot;
	 Node* prev=NULL;
	 //找最左边的节点，并记录路径上的所有节点
	 while(pCur||!s.empty())
	 {
	    while(pCur)
	    {
	       s.push(pCur);
	       pCur=pCur->_pLeft;
	    }
	    //取栈顶
	    Node* pTop=s.top();
		//右子树不存在
	    if(NULL == pTop->_pRight ||prev==pTop->_pRight)
	    {
		 cout<<pTop->_value<<" ";
		 prev=pTop;
		 s.pop();
	    }
		//右子树存在
	    else
		   pCur=pTop->_pRight;
	 }
	 cout<<endl;
	}