【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?

解答：

其实思路有点类似以前的一篇文章：【LeetCode从零单刷】Binary Tree Preorder Traversal

都是利用栈这个工具完成树的遍历。不过这道题中，因为第一个被访问的是左子树，所以栈中保存的是根节点。

保存子树节点与根节点的不同在于：根节点灵活性小，子树节点灵活性较大，判断是否到达树底更复杂。例如：

1. 【1，2，3，#，4】此时的 2 节点没有左子树，但是不能直接进入栈中元素的右子树，因为其本身还有一个右子树；
2. 【1，2，#，3】此时只有左子树，根本无法进入右子树，就栈不断返回元素。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
        vector<int> result;
        if(root == NULL)    return result;

        stack<TreeNode*> rootStack;
        TreeNode* tmp = root;
        bool tag = true;
        while(tag || !rootStack.empty())
        {
            while(tmp->left)
            {
                rootStack.push(tmp);
                tmp = tmp->left;
            }
            result.push_back(tmp->val);

            // 如果不是叶子节点，有右子树
            if(tmp->right)
                tmp = tmp->right;

            // 没有左子树且没有右子树，一定是叶子节点
            else if(!rootStack.empty())
            {
                tmp = rootStack.top();
                rootStack.pop();
                result.push_back(tmp->val);

                // 如果没有右子树，不断回溯
                while(tmp->right == NULL)
                {
                    if(rootStack.empty())
                    {
                        tag = false;
                        break;
                    }
                    else
                    {
                        tmp = rootStack.top();
                        result.push_back(tmp->val);
                        rootStack.pop();
                    }
                }
                if(tmp->right)
                {
                    tmp = tmp->right;
                }
            }
            else
            {
                tag = false;
            }
        }

        return result;
    }
};