二叉树前中后序遍历

#include<iostream>
#include<vector>
#include<stack>
#include<queue>
 
 
using namespace std;
struct TreeNode{
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int v) :val(v), left(NULL), right(NULL){}
};
 
 
 
 
//------------------树的前序遍历：根-左-右------------------------------
//---------------------递归法-------------------------------------------
 
vector<int> preorderTraversal_recursive(TreeNode *root, vector<int> &res)
{
 
	if (root == nullptr)
		return res;
	else
	{
		res.push_back(root->val);
		preorderTraversal_recursive(root->left,res);
		preorderTraversal_recursive(root->right,res);
		return res;
	}
 
}
 
 
//-----------------------非递归法-------------------------------------
vector<int> preorderTraversal_iteratively(TreeNode *root)
{
	vector<int> res;
	if (root == nullptr)
	{
		return res;
	}
	stack<TreeNode *> st;
	st.push(root);
	while (!st.empty())
	{
		TreeNode *node = st.top();
		st.pop();
		res.push_back(node->val);
		
		if (node->right)
			st.push(node->right);
		if (node->left)
			st.push(node->left);
			
	}
	return res;
}
 
 
//-------------------------树的中序遍历：左-根-右---------------------------
 
//-----------------------------递归法---------------------------------------
vector<int> inorderTraversal_recursive(TreeNode *root, vector<int> &res)
{
	if (root == nullptr)
		return res;
	else
	{
		inorderTraversal_recursive(root->left, res);
		res.push_back(root->val);
		inorderTraversal_recursive(root->right, res);
		return res;
	}
}
 
 
//-----------------------------非递归法---------------------------------------
vector<int> inorderTraversal_iteratively(TreeNode *root)
{
	vector<int> res;
	if (root == nullptr)
		return res;
	stack<TreeNode *> st;
 
	TreeNode *node = root;
	while (!st.empty()|| node)
	{ 
		
		while (node)
		{
			st.push(node);
			node = node->left;
		}
		if (!st.empty())
		{
			node = st.top();
			res.push_back(node->val);
			st.pop();
			node = node->right;
		}
	}
	return res;
}
 
 
 
//-------------------------树的后序遍历：左-右-根--------------------------------
//-----------------------------------递归法--------------------------------------
vector<int>  postorderTraversal_recursive(TreeNode *root, vector<int> &res)
{
	if (root == nullptr)
		return res;
	else
	{
		
		postorderTraversal_recursive(root->left, res);
		postorderTraversal_recursive(root->right, res);
		res.push_back(root->val);
		return res;
	}
}
 
 
 
//-----------------------------非递归法---------------------------------------
vector<int> postorderTraversal_iteratively(TreeNode *root)
{
	vector<int>res;
	if (root == nullptr)
		return res;
	stack<TreeNode *>st;
	st.push(root);
	while (!st.empty())
	{
		TreeNode *node = st.top();
		st.pop();
		res.push_back(node->val);
		if (node->left)
		{
			st.push(node->left);
		}
		if (node->right)
		{
			st.push(node->right);
		}
	}
	reverse(res.begin(), res.end());
	return res;
}
 
 
 
 
//-------------------------------------树的层次遍历--------------------------
 
vector<int> levelorderTraversal(TreeNode *root)
{
	vector<int>res;
	if (root == nullptr)
		return res;
	queue<TreeNode *>que;
	que.push(root);
	while (!que.empty())
	{
		TreeNode * node = que.front();
		que.pop();
		res.push_back(node->val);
		if (node->left)
			que.push(node->left);
		if (node->right)
			que.push(node->right);
	}
	return res;
}
 
int main()
{
	struct TreeNode *root = new TreeNode(1);
	root->left = new TreeNode(2);
	root->right = new TreeNode(3);
	root->right ->left= nullptr;
	root->right->right = nullptr;
	root->left->left = new TreeNode(4);
	root->left ->right= new TreeNode(5);
 
	vector<int>res;
 
	cout << "树的前序遍历：递归版" << endl;
	preorderTraversal_recursive(root,res);
	for (int i = 0; i < res.size(); i++)
	{
		cout << res[i] << " ";
	}
	cout << endl;
 
	
	cout << "树的前序遍历：迭代版" << endl;
	res = preorderTraversal_iteratively(root);
	for (int i = 0; i < res.size(); i++)
	{
		cout << res[i] << " ";
	}
	cout << endl<<endl;
 
	res.clear();
	cout << "树的中序遍历：递归版" << endl;
	inorderTraversal_recursive(root, res);
	for (int i = 0; i < res.size(); i++)
	{
		cout << res[i] << " ";
	}
	cout << endl;
 
 
	cout << "树的中序遍历:迭代版" << endl;
	res=inorderTraversal_iteratively(root);
	for (int i = 0; i < res.size(); i++)
	{
		cout << res[i] << " ";
	}
	cout << endl<<endl;
 
 
	res.clear();
	cout << "树的后序遍历：递归版" << endl;
	postorderTraversal_recursive(root, res);
	for (int i = 0; i < res.size(); i++)
	{
		cout << res[i] << " ";
	}
	cout << endl;
 
 
	cout << "树的后序遍历：迭代版" << endl;
	res = postorderTraversal_iteratively(root);
	for (int i = 0; i < res.size(); i++)
	{
		cout << res[i] << " ";
	}
	cout << endl << endl;
 
 
 
	cout << "树的层次遍历:" << endl;
	res = levelorderTraversal(root);
	for (int i = 0; i < res.size(); i++)
	{
		cout << res[i] << " ";
	}
	cout << endl << endl;
	return 0;
}