普通结构体- 递归函数返回string类型方法：

#include <bits/stdc++.h>
using namespace std;
// 定义二叉树节点结构
struct tree {
    char val;
    int left;
    int right;
};
// 构建二叉树
int build(vector<tree>& a, const string& str, int& pos) {
    int len = str.size();
    if (pos >= len) return -1; // 边界条件
    if (str[pos] == '.') { // 空节点
        pos++;
        return -1;
    }
    tree node;
    node.val = str[pos++]; // 当前节点的值
    node.left = build(a, str, pos); // 构建左子树
    node.right = build(a, str, pos); // 构建右子树
    a.push_back(node);
    return a.size() - 1; // 返回当前节点的索引
}
// 中序遍历返回字符串
string instring(const vector<tree>& a, int idx) {
    if (idx == -1) return ""; // 空节点
    string left = instring(a, a[idx].left); // 左子树的中序遍历
    string current(1, a[idx].val);         // 当前节点
    string right = instring(a, a[idx].right); // 右子树的中序遍历
    return left + current + right; // 中序遍历结果
}
// 后序遍历返回字符串
string poststring(const vector<tree>& a, int idx) {
    if (idx == -1) return ""; // 空节点
    string left = poststring(a, a[idx].left); // 左子树的后序遍历
    string right = poststring(a, a[idx].right); // 右子树的后序遍历
    string current(1, a[idx].val);           // 当前节点
    return left + right + current; // 后序遍历结果
}
int main() {
    string str;
    int pos = 0;
    cin >> str;
    vector<tree> a; // 节点数组
    int root = build(a, str, pos); // 构建二叉树
    string instr = instring(a, root); // 获取中序遍历结果
    string poststr = poststring(a, root); // 获取后序遍历结果
    cout << instr << endl; // 输出中序遍历
    cout << poststr << endl; // 输出后序遍历
    return 0;
}

结构体指针遍历方式：

#include <bits/stdc++.h>
using namespace std;

// 定义树的节点结构
struct TreeNode {
    char val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(char x) : val(x), left(nullptr), right(nullptr) {}
};

// 使用递归方法根据先序遍历构建二叉树
TreeNode* buildTree(const string& preOrder, int& index) {
    if (index >= preOrder.size()) return nullptr; // 超出范围
    char current = preOrder[index];
    index++; // 移动到下一个字符
    if (current == '.') return nullptr; // 空节点
    TreeNode* node = new TreeNode(current); // 创建新节点
    node->left = buildTree(preOrder, index); // 构建左子树
    node->right = buildTree(preOrder, index); // 构建右子树
    return node;
}

// 中序遍历函数，将结果存储在 inOrder 数组中
void inorderTraversal(TreeNode* root, string& inOrder) {
    if (root == nullptr) return;
    inorderTraversal(root->left, inOrder); // 遍历左子树
    inOrder += root->val; // 访问当前节点
    inorderTraversal(root->right, inOrder); // 遍历右子树
}

// 后序遍历函数，将结果存储在 postOrder 数组中
void postorderTraversal(TreeNode* root, string& postOrder) {
    if (root == nullptr) return;
    postorderTraversal(root->left, postOrder); // 遍历左子树
    postorderTraversal(root->right, postOrder); // 遍历右子树
    postOrder += root->val; // 访问当前节点
}

int main(){
    string preOrder;
    cin >> preOrder; // 读取先序遍历序列，如 ABD..EF..G..C..
    
    int index = 0; // 初始化索引
    TreeNode* root = buildTree(preOrder, index); // 构建二叉树
    
    string inOrder = "";
    inorderTraversal(root, inOrder); // 进行中序遍历
    string postOrder = "";
    postorderTraversal(root, postOrder); // 进行后序遍历
    
    // 输出结果
    cout << inOrder << "\n" << postOrder << "\n";
    
    return 0;
}

结构体数组遍历方式：

#include <bits/stdc++.h>
using namespace std;
struct treenode {
    char val;
    int left;
    int right;
};
// 递归函数，根据先序遍历构建二叉树
int buildtree(vector<treenode>& nodes, string& str, int& pos) { // 注意这里 pos 改为引用传递
    int len =str.size();
	if (pos >= len) return -1; // 超出范围
    if (str[pos] == '.') {
        pos++; // 跳过空节点
        return -1;
    }
    treenode node; // 创建当前节点
    node.val = str[pos++];
    node.left = buildtree(nodes, str, pos);  // 构建左子树
    node.right = buildtree(nodes, str, pos); // 构建右子树
    nodes.push_back(node); // 添加到节点数组
    return nodes.size() - 1; // 返回当前节点的索引
}

// 中序遍历函数
void inorder(vector<treenode>& nodes, int idx, string& order1) {
    if (idx == -1) return; // 空节点
    inorder(nodes, nodes[idx].left, order1);  // 遍历左子树
    order1 += nodes[idx].val;                 // 访问当前节点
    inorder(nodes, nodes[idx].right, order1); // 遍历右子树
}

// 后序遍历函数
void postorder(vector<treenode>& nodes, int idx, string& order2) {
    if (idx == -1) return; // 空节点
    postorder(nodes, nodes[idx].left, order2);  // 遍历左子树
    postorder(nodes, nodes[idx].right, order2); // 遍历右子树
    order2 += nodes[idx].val;                   // 访问当前节点
}
int main() {
    string str;
    cin >> str; // 读取先序遍历序列，如 ABD..EF..G..C..
    vector<treenode> nodes; // 节点数组
    int pos = 0;  // 当前解析的位置
    int root = buildtree(nodes, str, pos);
    string inorder_str = "";
    inorder(nodes, root, inorder_str);
    string postorder_str = "";
    postorder(nodes, root, postorder_str);
    cout << inorder_str << "\n" << postorder_str << "\n";
    return 0;
}