通过二叉树的拓展前序遍历序列读出中序遍历序列

拓展前序遍历序列的形式为：[根节点，左子树拓展前序遍历序列，右子树拓展前序遍历序列]

因此，我们可以根据这个拓展前序遍历序列来确定中序遍历序列。

具体步骤如下：

1. 首先，根据拓展前序遍历序列的定义，我们可以得到根节点的值。

2. 接着，根据根节点的值，我们可以将中序遍历序列分为左子树和右子树两部分。

3. 然后，我们可以递归地使用相同的方法来确定左子树的中序遍历序列和右子树的中序遍历序列。

4. 最终，我们将左子树的中序遍历序列和右子树的中序遍历序列按照根节点的位置合并起来，就得到了完整的中序遍历序列。

举个例子，假设我们有以下二叉树：

1
/ \
2 3
/ \
4 5

其拓展前序遍历序列为[1,2,4,null,null,5,null,null,3,null,null]，我们可以按照上述步骤来确定中序遍历序列：

1. 根节点为1。

2. 根据根节点的值，中序遍历序列可以分为左子树[4,2,5]和右子树[1,3]两部分。

3. 对于左子树，根节点为2，中序遍历序列可以分为左子树[4]和右子树[2,5]两部分；对于右子树，根节点为3，中序遍历序列可以分为左子树[1]和右子树[]两部分。

4. 将左子树的中序遍历序列[4]和右子树的中序遍历序列[2,5]按照根节点2的位置合并起来得到[4,2,5]；将左子树的中序遍历序列[1]和右子树的中序遍历序列[]按照根节点3的位置合并起来得到[1]。最终，将这两个序列合并起来得到完整的中序遍历序列[4,2,5,1,3]。

相关问题

通过二叉树的拓展前序遍历序列读出中序遍历序列，写出c++代码

这里假设拓展前序遍历序列的格式为：

节点值-左子树拓展前序遍历序列-右子树拓展前序遍历序列

例如，一棵二叉树的拓展前序遍历序列为：1-2-4-#-#-5-#-#-3-#-6-7-#-#-8-#-#

其中#代表空节点。

根据上述格式，我们可以很容易地从拓展前序遍历序列中提取出节点值和对应的左右子树拓展前序遍历序列。由于中序遍历序列的顺序为左子树节点值-根节点值-右子树节点值，因此我们可以通过递归的方式，先遍历左子树，再遍历根节点，最后遍历右子树，从而得到中序遍历序列。

具体的c代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_LEN 100

typedef struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

char* getNext(char* str) {
    // 获取下一个节点的拓展前序遍历字符串
    char* next = (char*)malloc(MAX_LEN * sizeof(char));
    int i = 0;
    while (*str != '-' && *str != '#' && *str != '\0') {
        next[i++] = *str;
        str++;
    }
    next[i] = '\0';
    return next;
}

TreeNode* buildTree(char* str) {
    if (*str == '#' || *str == '\0') {
        return NULL;
    }
    // 获取当前节点的值
    char* val_str = getNext(str);
    int val = atoi(val_str);
    free(val_str);

    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    root->val = val;
    // 获取左子树和右子树的拓展前序遍历字符串
    char* left_str = getNext(str + strlen(val_str) + 1);
    char* right_str = getNext(left_str + strlen(left_str) + 1);
    // 递归构建左子树和右子树
    root->left = buildTree(left_str);
    root->right = buildTree(right_str);
    free(left_str);
    free(right_str);
    return root;
}

void inorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    inorderTraversal(root->left);
    printf("%d ", root->val);
    inorderTraversal(root->right);
}

int main() {
    char str[MAX_LEN];
    printf("请输入拓展前序遍历序列：\n");
    scanf("%s", str);
    TreeNode* root = buildTree(str);
    printf("中序遍历序列为：\n");
    inorderTraversal(root);
    printf("\n");
    return 0;
}

通过二叉树的拓展前序遍历序列读出中序遍历序列，用模板类写出代码

模板类代码如下：

#include <iostream>
#include <vector>
#include <stack>
#include <unordered_map>

template <typename T>
class TreeNode {
public:
    T val;
    TreeNode* left;
    TreeNode* right;

    TreeNode(T v) : val(v), left(nullptr), right(nullptr) {}
};

template <typename T>
class Solution {
public:
    std::vector<T> getInorder(std::vector<T>& preorder, std::vector<T>& extend) {
        int n = preorder.size();
        std::stack<TreeNode<T>*> stk;
        TreeNode<T>* root = new TreeNode<T>(preorder[0]);
        stk.push(root);

        int j = 0;
        for (int i = 1; i < n; ++i) {
            TreeNode<T>* node = new TreeNode<T>(preorder[i]);
            if (extend[i] == 'L') {
                stk.top()->left = node;
            } else {
                while (!stk.empty() && stk.top()->right != nullptr) {
                    stk.pop();
                }
                if (!stk.empty()) {
                    stk.top()->right = node;
                }
            }
            stk.push(node);
        }

        std::vector<T> inorder(n);
        std::unordered_map<TreeNode<T>*, bool> vis;
        stk.push(root);
        while (!stk.empty()) {
            TreeNode<T>* node = stk.top();
            if (node->left && !vis[node->left]) {
                stk.push(node->left);
            } else {
                inorder[j++] = node->val;
                vis[node] = true;
                stk.pop();
                if (node->right && !vis[node->right]) {
                    stk.push(node->right);
                }
            }
        }

        return inorder;
    }
};

int main() {
    std::vector<int> preorder {1, 2, 4, 5, 3, 6, 7};
    std::vector<char> extend {'N', 'L', 'L', 'N', 'N', 'L', 'N'};
    Solution<int> s;
    std::vector<int> inorder = s.getInorder(preorder, extend);
    for (int i : inorder) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

其中，`getInorder`函数接收两个参数，分别是拓展前序遍历序列和拓展序列。首先根据拓展序列构建二叉树，然后进行中序遍历并记录结果。在构建二叉树时，我们可以使用一个栈来记录当前的遍历路径，如果遇到左子树，直接将节点作为父节点的左孩子；如果遇到右子树，需要在栈中找到第一个没有右孩子的父节点，将节点作为其右孩子。在遍历过程中，使用一个哈希表来记录节点是否被访问过，避免重复访问。最后返回中序遍历结果。