二叉树的七种遍历方式以及按行打印

void preorder_digui(TreeNode* pRoot, vector<int> &preorder_digui_re)
{
    if (pRoot != NULL)
    {
        preorder_digui_re.push_back(pRoot->val);
        if (pRoot->left)
            preorder_digui(pRoot->left, preorder_digui_re);
        if (pRoot->right)
            preorder_digui(pRoot->right, preorder_digui_re);
    }
}

void preorder_while(TreeNode* pRoot, vector<int> &preorder_while_re)
{
    stack <TreeNode*>stack1;
    while (pRoot || !stack1.empty())
    {
        if (pRoot == NULL)
        {
            pRoot = stack1.top();
            stack1.pop();
        }
        if (pRoot != NULL)
        {
            preorder_while_re.push_back(pRoot->val);
            if (pRoot->right)
                stack1.push(pRoot->right);
            pRoot = pRoot->left;
        }
    }
}

void inorder_digui(TreeNode* pRoot, vector<int> &inorder_digui_re)
{
    if (pRoot != NULL)
    {
        if (pRoot->left)
            inorder_digui(pRoot->left, inorder_digui_re);
        inorder_digui_re.push_back(pRoot->val);
        if (pRoot->right)
            inorder_digui(pRoot->right, inorder_digui_re);
    }
}

void inorder_while(TreeNode* pRoot, vector<int> &inorder_while_re)
{
    stack<TreeNode*>stack1;
    while (pRoot || !stack1.empty())
    {
        while (pRoot)
        {
            stack1.push(pRoot);
            pRoot = pRoot->left;
        }
        pRoot = stack1.top();
        stack1.pop();
        inorder_while_re.push_back(pRoot->val);
        pRoot = pRoot->right;
    }
}

void afterorder_digui(TreeNode* pRoot, vector<int> &afterorder_digui_re)
{
    if (pRoot != NULL)
    {
        if (pRoot->left)
            afterorder_digui(pRoot->left, afterorder_digui_re);
        if (pRoot->right)
            afterorder_digui(pRoot->right, afterorder_digui_re);
        afterorder_digui_re.push_back(pRoot->val);
    }
}

void afterorder_while(TreeNode* pRoot, vector<int> &afterorder_while_re)
{
    stack <TreeNode*>stack1;
    stack1.push(pRoot);
    stack1.push(pRoot);
    while (!stack1.empty())
    {
        pRoot = stack1.top();
        stack1.pop();
        if (!stack1.empty() && stack1.top() == pRoot)
        {
            if (pRoot->right)
            {
                stack1.push(pRoot->right);
                stack1.push(pRoot->right);
            }
            if (pRoot->left)
            {
                stack1.push(pRoot->left);
                stack1.push(pRoot->left);
            }
        }
        else
            afterorder_while_re.push_back(pRoot->val);
    }
}

void kuandu_while(TreeNode *pRoot, vector<int>&kuandu_while_re)
{
    queue<TreeNode*>queue1;
    queue1.push(pRoot);
    kuandu_while_re.push_back(pRoot->val);
    while (!queue1.empty())
    {
        queue<TreeNode*>queue2;
        while (!queue1.empty())
        {
            pRoot = queue1.front();
            queue1.pop();
            if (pRoot->left)
            {
                kuandu_while_re.push_back(pRoot->left->val);
                queue2.push(pRoot->left);
            }
            if (pRoot->right)
            {
                kuandu_while_re.push_back(pRoot->right->val);
                queue2.push(pRoot->right);
            }   
        }
        queue1 = queue2;
    }
}

void kuandu_hang(TreeNode *pRoot, vector<vector<int> > &kuandu_hang_re)
{
    queue<TreeNode*>queue1;
    queue1.push(pRoot);
    vector<int>re;
    re.push_back(pRoot->val);
    kuandu_hang_re.push_back(re);
    while (!queue1.empty())
    {
        queue<TreeNode*>queue2;
        vector<int>re;
        while (!queue1.empty())
        {
            pRoot = queue1.front();
            queue1.pop();
            if (pRoot->left)
            {
                re.push_back(pRoot->left->val);
                queue2.push(pRoot->left);
            }
            if (pRoot->right)
            {
                re.push_back(pRoot->right->val);
                queue2.push(pRoot->right);
            }
        }
        kuandu_hang_re.push_back(re);
        queue1 = queue2;
    }
}