树-前中后序层次-非递归

#include<iostream>
#include<vector>
#include<stack>
#include<queue>
 
 
using namespace std;
struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int v) :val(v), left(NULL), right(NULL){}
};
 
 
 
 
//------------------树的前序遍历：根-左-右------------------------------
//---------------------递归法-------------------------------------------
 
vector<int> preorderTraversal_recursive(TreeNode *root, vector<int> &res)
{
 
    if (root == nullptr)
        return res;
    else
    {
        res.push_back(root->val);
        preorderTraversal_recursive(root->left,res);
        preorderTraversal_recursive(root->right,res);
        return res;
    }
 
}
 
 
//-----------------------非递归法-------------------------------------
vector<int> preorderTraversal_iteratively(TreeNode *root)
{
    vector<int> res;
    if (root == nullptr)
    {
        return res;
    }
    stack<TreeNode *> st;
    st.push(root);
    while (!st.empty())
    {
        TreeNode *node = st.top();
        st.pop();
        res.push_back(node->val);
        
        if (node->right)
            st.push(node->right);
        if (node->left)
            st.push(node->left);
            
    }
    return res;
}
 
 
//-------------------------树的中序遍历：左-根-右---------------------------
 
//-----------------------------递归法---------------------------------------
vector<int> inorderTraversal_recursive(TreeNode *root, vector<int> &res)
{
    if (root == nullptr)
        return res;
    else
    {
        inorderTraversal_recursive(root->left, res);
        res.push_back(root->val);
        inorderTraversal_recursive(root->right, res);
        return res;
    }
}
 
 
//-----------------------------非递归法---------------------------------------
vector<int> inorderTraversal_iteratively(TreeNode *root)
{
    vector<int> res;
    if (root == nullptr)
        return res;
    stack<TreeNode *> st;
 
    TreeNode *node = root;
    while (!st.empty()|| node)
    { 
        
        while (node)
        {
            st.push(node);
            node = node->left;
        }
        if (!st.empty())
        {
            node = st.top();
            res.push_back(node->val);
            st.pop();
            node = node->right;
        }
    }
    return res;
}
 
 
 
//-------------------------树的后序遍历：左-右-根--------------------------------
//-----------------------------------递归法--------------------------------------
vector<int>  postorderTraversal_recursive(TreeNode *root, vector<int> &res)
{
    if (root == nullptr)
        return res;
    else
    {
        
        postorderTraversal_recursive(root->left, res);
        postorderTraversal_recursive(root->right, res);
        res.push_back(root->val);
        return res;
    }
}
 
 
 
//-----------------------------非递归法---------------------------------------
vector<int> postorderTraversal_iteratively(TreeNode *root)
{
    vector<int>res;
    if (root == nullptr)
        return res;
    stack<TreeNode *>st;
    st.push(root);
    while (!st.empty())
    {
        TreeNode *node = st.top();
        st.pop();
        res.push_back(node->val);
        if (node->left)
        {
            st.push(node->left);
        }
        if (node->right)
        {
            st.push(node->right);
        }
    }
    reverse(res.begin(), res.end());
    return res;
}
 
 
 
 
//-------------------------------------树的层次遍历--------------------------
 
vector<int> levelorderTraversal(TreeNode *root)
{
    vector<int>res;
    if (root == nullptr)
        return res;
    queue<TreeNode *>que;
    que.push(root);
    while (!que.empty())
    {
        TreeNode * node = que.front();
        que.pop();
        res.push_back(node->val);
        if (node->left)
            que.push(node->left);
        if (node->right)
            que.push(node->right);
    }
    return res;
}
 
int main()
{
    struct TreeNode *root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->right ->left= nullptr;
    root->right->right = nullptr;
    root->left->left = new TreeNode(4);
    root->left ->right= new TreeNode(5);
 
    vector<int>res;
 
    cout << "树的前序遍历：递归版" << endl;
    preorderTraversal_recursive(root,res);
    for (int i = 0; i < res.size(); i++)
    {
        cout << res[i] << " ";
    }
    cout << endl;
 
    
    cout << "树的前序遍历：迭代版" << endl;
    res = preorderTraversal_iteratively(root);
    for (int i = 0; i < res.size(); i++)
    {
        cout << res[i] << " ";
    }
    cout << endl<<endl;
 
    res.clear();
    cout << "树的中序遍历：递归版" << endl;
    inorderTraversal_recursive(root, res);
    for (int i = 0; i < res.size(); i++)
    {
        cout << res[i] << " ";
    }
    cout << endl;
 
 
    cout << "树的中序遍历:迭代版" << endl;
    res=inorderTraversal_iteratively(root);
    for (int i = 0; i < res.size(); i++)
    {
        cout << res[i] << " ";
    }
    cout << endl<<endl;
 
 
    res.clear();
    cout << "树的后序遍历：递归版" << endl;
    postorderTraversal_recursive(root, res);
    for (int i = 0; i < res.size(); i++)
    {
        cout << res[i] << " ";
    }
    cout << endl;
 
 
    cout << "树的后序遍历：迭代版" << endl;
    res = postorderTraversal_iteratively(root);
    for (int i = 0; i < res.size(); i++)
    {
        cout << res[i] << " ";
    }
    cout << endl << endl;
 
 
 
    cout << "树的层次遍历:" << endl;
    res = levelorderTraversal(root);
    for (int i = 0; i < res.size(); i++)
    {
        cout << res[i] << " ";
    }
    cout << endl << endl;
    return 0;
}
 ———————————————— 
版权声明：本文为CSDN博主「粉色的玛莎拉蒂」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_27962497/article/details/82191807