给我写出来c++版本的二叉树的遍历算法的程序设计思想，包括递归与非递归版本的先序中序以及后序遍历的算法的思想

二叉树遍历是指按照某种顺序依次访问二叉树的所有节点。常见的遍历方式有先序遍历、中序遍历和后序遍历。

递归版本的二叉树遍历算法的思想：
1. 先序遍历：先访问根节点，再递归访问左子树和右子树。
2. 中序遍历：先递归访问左子树，再访问根节点，最后递归访问右子树。
3. 后序遍历：先递归访问左子树和右子树，最后访问根节点。

非递归版本的二叉树遍历算法的思想：
1. 先序遍历：借助栈，先将根节点压入栈中，然后进入循环，每次从栈中弹出一个节点并访问它，然后把它的右子树和左子树依次压入栈中。
2. 中序遍历：借助栈，先将根节点以及它的所有左子树依次压入栈中，然后进入循环，每次从栈中弹出一个节点并访问它，如果它有右子树，则将其右子树以及右子树的所有左子树依次压入栈中。
3. 后序遍历：借助栈，先将根节点以及它的所有左子树依次压入栈中，然后进入循环，每次从栈中弹出一个节点并访问它，如果它有右子树，则将其右子树以及右子树的所有左子树依次压入栈中，同时将被弹出的节点标记为已访问。当一个节点的左右子树都被访问过时，就可以访问它了。

C++版本的代码实现如下：

#include <iostream>
#include <stack>

using namespace std;

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

// 递归版先序遍历
void preorderTraversal(TreeNode* root) {
    if (root == NULL) return;
    cout << root->val << " ";
    preorderTraversal(root->left);
    preorderTraversal(root->right);
}

// 非递归版先序遍历
void preorderTraversal2(TreeNode* root) {
    if (root == NULL) return;
    stack<TreeNode*> s;
    s.push(root);
    while (!s.empty()) {
        TreeNode* node = s.top();
        s.pop();
        cout << node->val << " ";
        if (node->right) s.push(node->right);
        if (node->left) s.push(node->left);
    }
}

// 递归版中序遍历
void inorderTraversal(TreeNode* root) {
    if (root == NULL) return;
    inorderTraversal(root->left);
    cout << root->val << " ";
    inorderTraversal(root->right);
}

// 非递归版中序遍历
void inorderTraversal2(TreeNode* root) {
    stack<TreeNode*> s;
    TreeNode* cur = root;
    while (cur || !s.empty()) {
        while (cur) {
            s.push(cur);
            cur = cur->left;
        }
        cur = s.top();
        s.pop();
        cout << cur->val << " ";
        cur = cur->right;
    }
}

// 递归版后序遍历
void postorderTraversal(TreeNode* root) {
    if (root == NULL) return;
    postorderTraversal(root->left);
    postorderTraversal(root->right);
    cout << root->val << " ";
}

// 非递归版后序遍历
void postorderTraversal2(TreeNode* root) {
    stack<TreeNode*> s;
    TreeNode* cur = root;
    TreeNode* last = NULL;
    while (cur || !s.empty()) {
        while (cur) {
            s.push(cur);
            cur = cur->left;
        }
        cur = s.top();
        if (cur->right == NULL || cur->right == last) {
            cout << cur->val << " ";
            s.pop();
            last = cur;
            cur = NULL;
        } else {
            cur = cur->right;
        }
    }
}

int main() {
    // 构建二叉树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    cout << "递归版先序遍历：";
    preorderTraversal(root);
    cout << endl;

    cout << "非递归版先序遍历：";
    preorderTraversal2(root);
    cout << endl;

    cout << "递归版中序遍历：";
    inorderTraversal(root);
    cout << endl;

    cout << "非递归版中序遍历：";
    inorderTraversal2(root);
    cout << endl;

    cout << "递归版后序遍历：";
    postorderTraversal(root);
    cout << endl;

    cout << "非递归版后序遍历：";
    postorderTraversal2(root);
    cout << endl;

    return 0;
}