vector<int> postorderTraversal(TreeNode *root) {

        vector<int> ans;

        vector<TreeNode *> stack;

        vector<bool> isRight;

        stack.push_back(root);

        isRight.push_back(false);

        TreeNode * pNode = NULL;

        while(!stack.empty())

        {

            while((pNode = stack.back()) != NULL)

            {

                pNode = pNode->left;

                stack.push_back(pNode);

                isRight.push_back(false);

            }

            while(isRight.back() == true)

            {

                stack.pop_back();

                isRight.pop_back();

                ans.push_back(stack.back()->val);

            }

            stack.pop_back();

            isRight.pop_back();

            if(!stack.empty())

            {

                pNode = stack.back();

                stack.push_back(pNode->right);

                isRight.push_back(true);

            }

        }

        return ans;

    }

    vector<int> postorderTraversal(TreeNode *root) {

        stack<TreeNode *> st;

        vector<int> vRet;

        TreeNode *p, *pre = root;

        if (!root) return vRet;

        p = root->left;

        st.push(root);

        while (!st.empty() )

        {

            while (p) { st.push(p); p = p->left; }

            p = st.top();

            while (!p->right || pre==p->right)

            {

                vRet.push_back(p->val);

                pre = p;

                st.pop();

                if (st.empty() ) break;

                p = st.top();

            }

            p = p->right;

        }

        return vRet;

    }