二叉树的非递归遍历：栈---->最简洁,最容易版.

后序遍历（左->右->根）：需要一个标记Lastvisited

只有两种情况才能弹出栈，1.右孩子节点为空，2.右孩子节点已经访问过(如果没有这条，那么会死循环再次push该孩子的右节点)

/**
 * 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;

    }
};

总结：

1.中序，后序遍历，因为都是"左"在前面，所以首先要依次进栈左孩子节点，然后弹出栈开始下一步处理。

2.这里，后序遍历需要一个访问标记，只有该孩子的右孩子节点为空，或者右孩子已经访问过，才弹出栈。

3.先序遍历，因为最先开始遍历根节点，所以采取的策略是一边遍历，一边进栈，而不是全部把左孩子进栈。