二叉树的前中后序遍历递归与迭代

/**
 * Definition for a binary tree node.
 * 
 */
struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

前序遍历

/*
* 前序遍历(递归+迭代）
*/
class PreorderTraveRecur {
public:
	vector<int> preorderTraversal(TreeNode* root) {
		vector<int>data;
		helper(root, data);
		return data;
	}
	void helper(TreeNode*root, vector<int>&data) {

		if (root != NULL) {
			data.push_back(root->val);
			if (root->left != NULL) {
				helper(root->left, data);
			}
			if (root->right != NULL) {
				helper(root->right, data);
			}
		}
	}
};

class PreorderTravIter {
public:
	vector<int> preorderTraversal(TreeNode* root) {

		vector<int>data;
		stack<TreeNode*> sk;
		TreeNode*curr = root;

		while (curr != NULL || !sk.empty()) {

			while (curr != NULL) {

				data.push_back(curr->val);
				sk.push(curr);
				curr = curr->left;
			}
			if (!sk.empty()) { //

				curr = sk.top();
				sk.pop();
				curr = curr->right;
			}
		}
		return data;
	}
};

中序遍历

/*
* 中序遍历（递归+迭代）
*/
class InorderTraveRecur {
	
public:
	vector<int> inorderTraversal(TreeNode* root) {
		vector<int>data;
		helper(root, data);
		return data;
	}

	void helper(TreeNode*root, vector<int>&data) {
		if (root != NULL) {
			if (root->left != NULL) {
				helper(root->left, data);
			}
			data.push_back(root->val);
			if (root->right != NULL) {
				helper(root->right, data);
			}
		}
	}
};

class InorderTraveIter {

public:
	vector<int> inorderTraversal(TreeNode* root) {

		vector<int>data;
		stack<TreeNode*> sk;
		TreeNode*curr = root;

		while (curr != NULL||!sk.empty()) {

			while(curr != NULL) {
				sk.push(curr);
				curr = curr->left;
			}

			if (!sk.empty()) { //
				curr = sk.top();
				sk.pop();
				data.push_back(curr->val);
				curr = curr->right;
			}
		}
		return data;
	}

	
};

后序遍历

/*
* 后序遍历（递归+迭代）
*/
class PostorderTravRecur {
public:
	vector<int> postorderTraversal(TreeNode* root) {
		vector<int>data;
		helper(root, data);
		return data;
	}
	void helper(TreeNode*root, vector<int>&data) {
		if (root != NULL) {
			if (root->left != NULL) {
				helper(root->left, data);
			}
			if (root->right != NULL) {
				helper(root->right, data);
			}
			data.push_back(root->val);
		}
	}
};

class PostorderTravIter {
public:
	vector<int> postorderTraversal(TreeNode* root) {
		vector<int>data;
		stack<pair<TreeNode*,bool>> sk;//加一个访问标志
		TreeNode*curr = root;

		while (curr != NULL || !sk.empty()) {

			while (curr != NULL) {
				sk.push(make_pair(curr,true));
				curr = curr->left;
			}

			if (!sk.empty()) { 

				pair<TreeNode*, bool> p = sk.top();
				sk.pop();
				if (p.second) {//表示是第一次出现在栈顶(缓冲一步)
					sk.push(make_pair(p.first, false));
					curr = p.first->right;
				}
				else {
					data.push_back(p.first->val);
					curr = NULL;
				}
			}
		}
		return data;
	}
	
};

统一的迭代遍历

//非递归前序遍历
vector<int> preorderTraversal(TreeNode *root)
{
	vector<int> path;
	stack< pair<TreeNode *, bool> > s;
	TreeNode* curr = root;
	s.push(make_pair(curr, false));

	while (!s.empty())
	{
		pair<TreeNode *, bool>p = s.top();
		curr =p.first;
		s.pop();
		if (curr== NULL)
			continue;
		if (p.second)
		{
			path.push_back(curr->val);
		}
		else
		{
			s.push(make_pair(curr->right, false));
			s.push(make_pair(curr->left, false));
			s.push(make_pair(curr, true));
		}
	}
	return path;
}

//非递归中序遍历
vector<int> inorderTraversal(TreeNode *root)
{
	vector<int> path;
	stack< pair<TreeNode *, bool> > s;
	TreeNode* curr = root;
	s.push(make_pair(curr, false));

	while (!s.empty())
	{
		pair<TreeNode *, bool>p = s.top();
		curr = p.first;
		s.pop();
		if (curr == NULL)
			continue;
		if (p.second)
		{
			path.push_back(curr->val);
		}
		else
		{
			s.push(make_pair(curr->right, false));
			s.push(make_pair(curr, true));
			s.push(make_pair(curr->left, false));
		}
	}
	return path;
}
//非递归后序遍历
vector<int> postorderTraversal(TreeNode *root)
{
	vector<int> path;
	stack< pair<TreeNode *, bool> > s;
	TreeNode* curr = root;
	s.push(make_pair(curr, false));

	while (!s.empty())
	{
		pair<TreeNode *, bool>p = s.top();
		curr = p.first;
		s.pop();
		if (curr == NULL)
			continue;
		if (p.second)
		{
			path.push_back(curr->val);
		}
		else
		{
			s.push(make_pair(curr, true));
			s.push(make_pair(curr->right, false));
			s.push(make_pair(curr->left, false));
		}
	}
	return path;
}