LeetCode Binary Tree Inorder Traversal 中序遍历二叉树

Given a binary tree, return the inorder traversal of its nodes' values.

For example:

Given binary tree

{1,#,2,3}

,

1
    \
     2
    /
   3

return

[1,3,2]

.

Note: Recursive solution is trivial, could you do it iteratively?

confused what

"{1,#,2,3}"

means? >
read more on how binary tree is serialized on OJ.

OJ's Binary Tree Serialization:
The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.
Here's an example:

1
  / \
 2   3
    /
   4
    \
     5

The above binary tree is serialized as

"{1,2,3,#,#,4,#,#,5}"

.
会如何保存这个Vector中间数据，就能解决这道题目了。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
	vector<int> inorderTraversal(TreeNode *root) {
		vector<int> vi;
		inHelper(root, vi);
		return vi;
	}

	void inHelper(TreeNode *node, vector<int>& vi)
	{
		if(node == nullptr) return;
		inHelper(node->left, vi);
		vi.push_back(node->val);
		inHelper(node->right, vi);
	}
};

2014-1-9 update iterative的解法，我使用一个标志flag，判断是否遍历过的节点：

vector<int> inorderTraversal(TreeNode *root) 
	{
		vector<int> rs;
		if (!root) return rs;
		stack<TreeNode *> stk;
		stk.push(root);
		bool flag = false;
		while (!stk.empty())
		{
			if (!flag)
				while (stk.top()->left) stk.push(stk.top()->left);
			TreeNode *t = stk.top();
			rs.push_back(t->val);
			stk.pop();
			flag = true;
			if (t->right) 
			{
				stk.push(t->right);
				flag = false;
			}
		}
		return rs;
	}

或者如下，leetcode上解说的算法：

vector<int> inorderTraversal(TreeNode *root) 
	{
		vector<int> rs;
		if (!root) return rs;
		stack<TreeNode *> stk;
		TreeNode *p = root;
		while (!stk.empty() || p)
		{
			if (p)
			{
				stk.push(p);
				p = p->left;
			}
			else
			{
				p = stk.top();
				stk.pop();
				rs.push_back(p->val);
				p = p->right;
			}
		}
		return rs;
	}

理解了树的操作就好办了，破坏原树的结果输出的程序：

vector<int> inorderTraversal(TreeNode *root) 
	{
		vector<int> rs;
		if (!root) return rs;
		stack<TreeNode *> stk;
		stk.push(root);
		while (!stk.empty())
		{
			while (stk.top()->left) stk.push(stk.top()->left);
			TreeNode *t = stk.top();
			rs.push_back(t->val);
			stk.pop();
			if (!stk.empty()) stk.top()->left = nullptr;
			if (t->right) stk.push(t->right);
		}
		return rs;
	}

//2014-2-14 update
	vector<int> inorderTraversal(TreeNode *root) 
	{
		vector<int> rs;
		if (!root) return rs;
		stack<TreeNode *> stk;
		stk.push(root);
		while (!stk.empty())
		{
			while (stk.top()->left) stk.push(stk.top()->left);
			TreeNode *t = stk.top();
			stk.pop();
			if (!stk.empty()) stk.top()->left = nullptr;
			rs.push_back(t->val);
			if (t->right) stk.push(t->right);
		}
		return rs;
	}