後序遍歷（左->右->根）：需要一個標記Lastvisited

/**
 * 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> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==NULL) return res;
        stack<TreeNode*> st;
        while(root)
        {
            st.push(root);
            root=root->left;
        }

        TreeNode* LastVisted=NULL;//標記已經訪問過的，不然會再次進棧。

        while(!st.empty())
        {
            TreeNode* top=st.top();
            if(top->right==NULL||top->right==LastVisted)//右孩子節點為空，或者右孩子節點已經訪問過。
            {
                st.pop();
                LastVisted=top;
                res.push_back(top->val);
            }else
            {
                TreeNode *p=top->right;
                while(p)
                {
                    st.push(p);
                    p=p->left;
                }
            }
        }
        return res;
    }
};
 

/**
 * 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) {
        vector<int> res;
        if(root==NULL) return res;
        stack<TreeNode*> st;
        while(root)
        {
            st.push(root);
            root=root->left;
        }
        while(!st.empty())
        {
            TreeNode*top=st.top();
            st.pop();
            res.push_back(top->val);

            TreeNode*p=top->right;
            while(p)
            {
                st.push(p);
                p=p->left;
            }      

        }
        return res;
    }
};
 

/**
 * 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> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==NULL) return res;

        stack<TreeNode*> st;
        st.push(root);

        while(!st.empty())
        {
            TreeNode*top=st.top();
            st.pop();
            res.push_back(top->val);
            if(top->right) st.push(top->right);
            if(top->left) st.push(top->left);
        }
        return res;

    }
};