二叉树的中序，前序，后序非递归遍历

struct TreeNode
{
	int val;
	TreeNode * left;
	TreeNode * right;
	TreeNode(int x):val(x),left(NULL),right(NULL)
	{

	}
};
// in-order Traverse
void inOrderTraverse(TreeNode * root)
{
	if(root==NULL)
	{
		return;
	}
	TreeNode *p=root;
	stack<TreeNode*> s;
	while(p!=NULL||!s.empty())
	{
		while(p!=NULL)
		{
			s.push(p);
			p=p->left;
		}
		if(!s.empty())
		{
			p=s.top();
			cout<<p->val<<end;
			s.pop();
			p=p->right;
		}
	}

}
//pre-order Traverse
void preOrderTraverse(TreeNode * root)
{
	if(root==NULL)
	{
		return;
	}
	stack<TreeNode*> s;
	s.push(root);
	while(!s.empty())
	{
		TreeNode * cur=s.top();
		s.pop();
		cout<<cur->val;
		if(cur->right)
		{
			s.push(cur->right);
		}
		if(cur->left)
		{
			s.push(cur->left);
		}
	}

}
// pos-order Traverse
/**
 * 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> result;
        if(root==NULL)
        {
            return result;
            
        }
        stack<TreeNode*> stk;
        stk.push(root);
        stack<int> out;
        while(!stk.empty())
        {
            TreeNode * cur=stk.top();
            out.push(cur->val);
            stk.pop();
            if(cur->left)
            {
                stk.push(cur->left);
                
            }
            if(cur->right)
            {
                stk.push(cur->right);
            }
        }
        while(!out.empty())
        {
            result.push_back(out.top());
            out.pop();
        }
        return result;
    }
};