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

前序：
1、首先申请一个新的栈，为stack
2、将头节点head压入stack；
3、每次从栈中弹出栈顶节点，记为cur，然后打印cur节点的值，如果cur的右孩子不为空的话，将右孩子压入栈中，如果cur的左孩子不为空的话，讲cur得左孩子压入栈中。
4、不断重复3，知道stack为空，全部过程结束
中序：
1、首先申请一个栈a申请一个变量cur，cur为头结点
2、把节点压入栈中，对cur节点为头的整颗子树来说，依次把左节点压入栈，重复2。
3、重复2，直到cur为空，此时stack弹出一个节点，为cur；
打印cur，cur=cur.right重复2.
4、stack为空并且cur为空，整个过程结束。
后序：
1、申请一个栈，s1，头结点放入s1，
2、从s1弹出的节点记为cur，把cur左孩子压入s1，把cur右孩子压入s1.
3、把从s1弹出的放入s2
4、重复2,3，直到s1为空，结束。
5、s2依次弹出节点，并打印

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

class TreeToSequence {
public:
    void func1(TreeNode* root,vector<int> &v)
        {
        if(root==NULL)
            return;
        stack<TreeNode*> s1;
        s1.push(root);
        //TreeNode *cur=root;

        while(!s1.empty())
            {
             TreeNode* cur=s1.top();
            s1.pop();
            v.push_back(cur->val);
            if(cur->right!=NULL)
                s1.push(cur->right);
            if(cur->left!=NULL)
                s1.push(cur->left);
        }

    }
    void func2(TreeNode* root,vector<int> &v)
        {
        if(root==NULL)
            return;
        stack<TreeNode*> s;
       TreeNode* cur=root;
        while(!s.empty()||cur!=NULL)
            {
        while(cur!=NULL)
            {
            s.push(cur);
            cur=cur->left;
        }
        cur=s.top();
        s.pop();
        v.push_back(cur->val);
        cur=cur->right;
        }
    }
    void func3(TreeNode* root,vector<int> &v)
        {
        if(root==NULL)
            return;
        stack<TreeNode*> s1;
        stack<TreeNode*> s2;
        s1.push(root);
        while(!s1.empty())
            {
             TreeNode* cur=s1.top();
            s1.pop();
            s2.push(cur);
            if(cur->left!=NULL)
                {
            s1.push(cur->left);
            }
            if(cur->right!=NULL)
                {

            s1.push(cur->right);
            }

        }
        while(!s2.empty())
            {
            TreeNode* a=s2.top();
            s2.pop();
            v.push_back(a->val);
        }
    }
    vector<vector<int> > convert(TreeNode* root) {
        // write code here
        vector<int> v1;
        vector<int> v2;
        vector<int> v3;
        vector<vector<int>> v;
        func1(root,v1);
        func2(root,v2);
        func3(root,v3);
        v.push_back(v1);
        v.push_back(v2);
        v.push_back(v3);
        return v;
    }
};