二叉树的先序、中序、后序遍历（递归、非递归实现）

一、二叉树遍历问题（递归、非递归）

1. 二叉树的先序遍历

- 先序1：二叉树递归先序遍历:

void PreOrderTree1(BtNode *T)
{
	if(T != NULL)
	{
		cout<< T->data<<" ";
		PreOrderTree1(T->left);
	    PreOrderTree1(T->right);
	}
}

- 先序2：二叉树递归先序遍历 (利用vector)

class BT 
{
public :
	vector<int> vec;
	vector<int> PreOrderTree2(BtNode *T)
	{
		if( T == NULL)
		{
			return vec;
		}
		vec.push_back (T->data);
		PreOrderTree2 (T->left);
		PreOrderTree2 (T->right);
		return vec;
	}
};

- 先序3： 二叉树非递归先序遍历 (利用栈) 根左右

***********************************************先序1*************************************************
void NicePreOrder(BtNode *ptr)
{
	if(NULL == ptr) 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;
}

**********************************************先序2*************************************************
 void PreOrderTree3(BtNode *T)
 {
	 if(T == NULL)
	 {
		 return ;
	 }
	 stack <BtNode *> st1;
	 st1.push (T);               //栈里面入根
	while(T != NULL || !st1.empty())
	{    //节点不为空
		 while(T!= NULL)
		 {
			 st1.push(T);
			 T->left;
		 }
		 if(! st1.empty())
		 {
			 T=st1.top();
			 st1.pop();
			 cout<<T<<" ";
			 T->right;
		 }
	 }
	 cout <<endl;
 }

2. 二叉树的中序遍历

- 中序1：二叉树递归中序遍历

void InOrderTree1(BtNode *T)
{
	if(T != NULL)
	{
		InOrderTree1(T->left);
		cout<< T->data<<" ";
		InOrderTree1(T->right);
	}
}

- 中序2：二叉树递归中序遍历(利用vector)

class BT 
{
public :
	vector<int> vec;
	vector<int> InOrderTree2(BtNode *T)
	{
		if( T == NULL)
		{
			return vec;
		}
		InOrderTree2 (T->left);
		vec.push_back (T->data);
		InOrderTree2 (T->right);
		return vec;
	}
};

- 中序3：二叉树非递归中序遍历(利用栈)

**********************************************中序1*************************************************
void NiceInOrder(BtNode *ptr)
{
	if(NULL == ptr) 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;
}

6. 二叉树的后序遍历

- 后序1：二叉树递归后序遍历

void PastTree1(BtNode *T)
{
	if(T != NULL)
	{
		PastTree1(T->left);
		PastTree1(T->right);
		cout<< T->data<<" ";
	}
}

• 后序2：二叉树非递归后序遍历 （利用stack）

***********************************************后序*************************************************
void NicePastOrder(BtNode *ptr)
{
	if(NULL == ptr) return ;
	stack<BtNode*> st;
	BtNode *tag = NULL;
	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;
}

非递归层次遍历：

void NiceLevelOrder(BtNode *ptr)
{
	if(NULL == ptr) return ;
	queue<BtNode*> qu;
	qu.push(ptr); // root;
	while(!qu.empty())
	{
		ptr = qu.front(); qu.pop();
		cout<<ptr->data<<" ";
		if(ptr->leftchild != NULL)
		{
			qu.push(ptr->leftchild);
		}
		if(ptr->rightchild != NULL)
		{
			qu.push(ptr->rightchild);
		}
	}
	cout<<endl;
}