非递归二叉树的遍历打印

题目描述：

请用非递归方式实现二叉树的先序、中序和后序的遍历打印。

给定一个二叉树的根结点root，请依次返回二叉树的先序，中序和后续遍历(二维数组的形式)。
先序
先序遍历的规则：根 左 右
先序遍历的结果：1 2 4 5 3 6 7
举例说明：

1、节点1入栈，弹出、打印；
2、将弹出的节点1的右孩子3先入栈，左孩子2后入栈；

3、2出栈，2的右、左孩子依次入栈

4、重复上述步骤，保证：弹出节点的右孩子先入栈，左孩子再入栈，直至栈空
中序
中序遍历的规则： 左 根 右
中序遍历的结果：4 2 5 1 6 3 7
举例说明：

1、节点1、2、4依次入栈；
2、当节点4的左孩子为空时，节点4出栈，cur指针指向弹出节点4；
3、当节点4的右孩子为空时，节点2继续出栈，cur指向2；
当节点2的右孩子不为空时，节点5进栈，cur指向节点5；
4、 重复2，3；

后序
后序遍历的规则： 左 右 根
后序遍历的结果：4 5 2 6 7 3 1
举例说明：

1、节点1入栈，弹出并打印；
2、节点1的左节点存在，节点2入栈；
节点1的右节点存在，节点3入栈；

3、栈顶节点3弹出，3的左右节点入栈；
。。。
将栈1弹出的所有节点一次入栈2；栈2依次弹出的节点为最后的结果。

代码：

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

class TreeToSequence {
public:
    vector<vector<int> > convert(TreeNode* root) {
        vector<vector<int>> output;
        stack<TreeNode*> stk;
        vector<int> array;
        // 非递归先序
        first(root,stk,array);
        output.push_back(array);
        array.clear();
        // 非递归中序
        middle(root,stk,array);
        output.push_back(array);
        array.clear();
        // 非递归后序
        last(root,stk,array);
        output.push_back(array);
        array.clear();
        return output;
    }
    void first(TreeNode* node,stack<TreeNode*> &stk,vector<int> &array){
        if(node == nullptr) return;
        TreeNode* cur = nullptr;
        // 注意：可以直接在栈中push节点
        stk.push(node);
        while(!stk.empty()){
            // 栈头指向的可能是节点类型的变量，判断的是弹出的cur节点的左右子树
            cur = stk.top();
            array.push_back(cur->val);
            stk.pop();
            if(cur->right){
                stk.push(cur->right);
            }
            if(cur->left){
                stk.push(cur->left);
            }
        }
    }
    void middle(TreeNode* node,stack<TreeNode*> &stk,vector<int> &array){
        if(node == nullptr) return;
        // node有左孩子一直进栈，node没有右孩子继续出栈，若有右孩子则进栈；
        TreeNode* cur = node;
        while(cur != nullptr || !stk.empty()){
            if(cur != nullptr){
                stk.push(cur);
                cur = cur->left;
            }else{
                cur = stk.top();
                array.push_back(cur->val);
                stk.pop();
                cur = cur->right;
            }
        }
    }
    // 使用2个栈实现，stk 和 stk1
    void last(TreeNode* node,stack<TreeNode*> &stk,vector<int> &array){
        stack<int> stk1;
        TreeNode* cur = nullptr;
        int value=0;
        stk.push(node);
        while(!stk.empty()){
            cur = stk.top();
            stk1.push(cur->val);
            stk.pop();
            if(cur->left){
                stk.push(cur->left);
            }
            if(cur->right){
                stk.push(cur->right);
            }
        }
        while(!stk1.empty()){
            value = stk1.top();
            array.push_back(value);
            stk1.pop();
        }
    }
};