C++二叉树的遍历，包含递归及非递归写法

前言

二叉树的前序，中序及后序遍历，包含了递归写法及非递归写法

代码

#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<queue>

using namespace std;
struct Node
{
    double val;
    Node *left, *right;
    Node(): val(0.0), left(NULL), right(NULL){};
    Node(int &value):val(value), left(NULL), right(NULL){};
    Node(Node &tmp):val(tmp.val), left(tmp.left), right(tmp.right){};
};

class Tree
{
public:
    Node *root;
    Tree():root(NULL){};
    Tree(Node *root1):root(root1){};
    void preorderTraversal_dfs(Node *root, vector<double> &res);
    void preorderTraversal(Node *root, vector<double> &res);
    void inorderTraversal_dfs(Node *root, vector<double> &res);
    void inorderTraversal(Node *root, vector<double> &res);
    void postorderTraversal(Node *root, vector<double> &res);
    void postorderTraversal_dfs(Node *root, vector<double> &res);

};

void Tree::preorderTraversal_dfs(Node *root, vector<double> &res)
{
    if (root == NULL)
        return;
    res.push_back(root->val);
    if(root->left)
        preorderTraversal_dfs(root->left, res);
    if(root->right)
        preorderTraversal_dfs(root->right, res);
    return;
}

void Tree::preorderTraversal(Node *root, vector<double> &res)
{
    stack<Node *> S;
    Node *p = root;
    while(!S.empty() || p)
    {
        if (p)
        {
            res.push_back(p->val);
            p = p->left;
            S.push(p);
        }
        else
        {
            p = S.top();
            S.pop();
            p = p->right;
        }
    }
}

void Tree::inorderTraversal_dfs(Node *root, vector<double> &res)
{
    if (root == NULL)
        return;
    if(root->left)
        inorderTraversal_dfs(root->left, res);
    res.push_back(root->val);
    if(root->right)
        inorderTraversal_dfs(root->right, res);
}

void Tree::inorderTraversal(Node *root, vector<double> &res)
{
    stack<Node *> S;
    Node *p = root;
    while(!S.empty() || p)
    {
        if(p)
        {
            S.push(p);
            p = p->left;
        }
        else
        {
            p = S.top();
            S.pop();
            res.push_back(p->val);
            p = p->right;
        }
    }
}

void Tree::postorderTraversal_dfs(Node *root, vector<double> &res)
{
    if (root == NULL)
        return;
    if(root->left)
        postorderTraversal_dfs(root, res);
    if(root->right)
        postorderTraversal_dfs(root, res);
    res.push_back(root->val);


}

void Tree::postorderTraversal(Node *root, vector<double> &res)
{
    stack<Node *> S;
    Node *p = root;
    while(!S.empty() || p)
    {
        if(p)
        {
            res.insert(res.begin(), p->val);
            p = p->right;
            S.push(p);
        }
        else
        {
            p = S.top();
            S.pop();
            p = p->left;
        }
    }
}

int main()
{

}