94. Binary Tree Inorder Traversal(Tree, stack)

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

For example:
Given binary tree [1,null,2,3],

   1
    \
     2
    /
   3

return [1,3,2].

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

法I: recursion

/**
 * Definition for a binary tree node.
 * 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) {
        inorder(root);
        return ret;
    }
    
    void inorder(TreeNode* root){
        if(root==NULL) return;
        
        inorder(root->left);
        ret.push_back(root->val);
        inorder(root->right);
        return;

    }
private: 
    vector<int> ret;
};

法II:iteration

/**
 * Definition for a binary tree node.
 * 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) {
        if(root==NULL) return ret;
        
        TreeNode* current = root;
        stack<TreeNode*> s;
        s.push(current);
        while(1){
            while(current->left){
                    s.push(current->left); //push left child
                    current = current->left;
                    flag.insert(current);
                }
            
            //After iterate left tree, visit root
            while(!s.empty() && s.top()->right == NULL){
                current = s.top();
                s.pop(); //pop root
                ret.push_back(current->val); //visit root
            }
            if(s.empty()) break; //terminate when stack is empty
            current = s.top();
            s.pop(); //pop root
            ret.push_back(current->val); //visit root
            
            //go to right child
            s.push(current->right);  //push right child
            current = current->right;
        }
  
        return ret;
    }
    
private: 
    vector<int> ret;
};