<think>我们已知二叉树的先序遍历和中序遍历，可以唯一确定一棵二叉树，进而得到后序遍历。
思路：
1. 先序遍历的第一个元素是根节点。
2. 在中序遍历中找到这个根节点，则根节点左边是左子树的中序遍历，右边是右子树的中序遍历。
3. 根据左子树的长度，可以在先序遍历中确定左子树的先序遍历和右子树的先序遍历。
4. 递归处理左子树和右子树。
5. 后序遍历的顺序是：左子树 -> 右子树 -> 根节点。因此，在递归处理完左右子树后，将根节点加入后序遍历序列。
具体步骤：
假设先序遍历序列为pre，中序遍历序列为in，当前子树在先序遍历中的区间为[preStart, preEnd]，在中序遍历中的区间为[inStart, inEnd]。
递归函数：buildTree(vector<int>& pre, vector<int>& in, int preStart, int preEnd, int inStart, int inEnd)
或者使用索引和长度，但这里我们使用索引区间。
注意：递归终止条件是区间长度小于等于0。
然而，为了得到后序遍历，我们可以在递归过程中构建树，然后进行后序遍历。但也可以直接生成后序遍历序列，而不显式构建树。
我们可以这样：
递归构建左右子树，然后将根节点加入后序序列。
但是，题目要求输出后序遍历，我们可以直接输出吗？还是需要返回一个序列？
这里我们用一个数组post来存储后序遍历序列，在递归过程中，我们先递归左子树，再递归右子树，然后将根节点存入post。
另一种方法：在递归过程中，我们并不需要显式构建树，而是根据两个序列递归地确定根节点，然后确定左右子树的范围，递归处理左右子树，最后将根节点加入后序序列。
步骤：
1. 如果当前区间为空（preStart > preEnd），则返回。
2. 取先序遍历的第一个元素（即pre[preStart]）作为根节点。
3. 在中序遍历序列in的[inStart, inEnd]区间内找到根节点的位置，记为index。
4. 计算左子树的节点个数：leftSize = index - inStart。
5. 递归处理左子树：左子树在先序遍历中的区间为[preStart+1, preStart+leftSize]，在中序遍历中的区间为[inStart, index-1]。
6. 递归处理右子树：右子树在先序遍历中的区间为[preStart+leftSize+1, preEnd]，在中序遍历中的区间为[index+1, inEnd]。
7. 将根节点加入后序序列（因为后序遍历是左右根，所以递归完左右子树后再加入根节点）。
注意：后序遍历序列的存储位置，我们可以通过传引用的方式传递一个vector，然后在递归函数中往里面添加节点。
但是，这样得到的后序遍历序列，其顺序就是后序遍历的顺序。
实现代码：
我们设计一个递归函数：
void buildPost(vector<int>& pre, vector<int>& in, vector<int>& post,
int preStart, int preEnd, int inStart, int inEnd)
然而，由于递归过程中需要频繁计算区间，且递归函数参数较多，我们可以考虑使用辅助函数。
另外，我们也可以使用另一种方法：不传递区间，而是传递子序列的起始位置和长度，但这里我们使用区间索引（左闭右闭）。
注意：在递归过程中，我们使用引用传递pre和in，以及post，但区间索引是值传递。
但是，在递归之前，我们需要确保中序遍历序列中能找到根节点，否则需要处理错误情况（题目保证序列正确，所以不考虑）。
具体代码实现：
步骤：
1. 如果preStart > preEnd，说明没有节点，返回。
2. 根节点值为pre[preStart]。
3. 在中序遍历序列in的inStart到inEnd范围内查找根节点值，得到位置index。
4. 左子树节点数：leftSize = index - inStart。
5. 递归构建左子树：buildPost(pre, in, post, preStart+1, preStart+leftSize, inStart, index-1);
6. 递归构建右子树：buildPost(pre, in, post, preStart+leftSize+1, preEnd, index+1, inEnd);
7. 将根节点值加入post（后序序列）。
这样，当递归结束后，post中存储的就是后序遍历序列。
但是，注意：我们也可以不用传递post的引用，而是通过函数返回子树的后序遍历序列，然后合并（左子树序列+右子树序列+根节点），但这样会频繁创建vector，效率较低。所以使用引用传递。
另外，我们也可以使用迭代器来分割序列，但这里使用索引区间更直观。
主函数调用：
vector<int> postorder;
buildPost(preorder, inorder, postorder, 0, preorder.size()-1, 0, inorder.size()-1);
最后，postorder中存储的就是后序遍历序列。
但是，我们还需要考虑中序遍历中查找根节点的效率。我们可以提前建立一个中序遍历值到索引的映射，这样就不用每次循环查找了。
优化：在递归开始前，先构建一个中序遍历的哈希表（值->索引），这样查找根节点的位置就是$O(1)$。
因此，我们修改函数，增加一个map参数，或者将map作为全局变量，或者作为辅助函数的成员。
我们可以在主函数中构建一个unordered_map，然后传递给递归函数。
修改后的递归函数：
void buildPost(vector<int>& pre, vector<int>& in, vector<int>& post,
int preStart, int preEnd, int inStart, int inEnd,
unordered_map<int, int>& inMap)
在递归函数内，查找根节点位置：
int rootValue = pre[preStart];
int index = inMap[rootValue]; // 直接得到索引
注意：这个索引是相对于整个中序遍历序列的，我们需要确保它在当前区间[inStart, inEnd]内？但是根据问题描述，序列是有效的，所以可以认为在。
但是，如果不在，则说明序列错误，我们可以抛出异常，但题目保证正确，所以不考虑。
代码实现：
步骤：
1. 构建inMap：遍历in数组，将每个元素的值和位置存入map。
2. 调用递归函数。
递归函数内部：
if (preStart > preEnd) return;
int rootValue = pre[preStart];
int index = inMap[rootValue]; // 根节点在中序遍历中的位置
int leftSize = index - inStart; // 左子树节点个数
// 递归左子树
buildPost(pre, in, post, preStart+1, preStart+leftSize, inStart, index-1, inMap);
// 递归右子树
buildPost(pre, in, post, preStart+leftSize+1, preEnd, index+1, inEnd, inMap);
// 将根节点加入后序序列
post.push_back(rootValue);
这样，后序序列post就是后序遍历的结果。
但是，注意：我们递归调用时，区间是左闭右闭的。
完整代码示例：
注意：我们假设二叉树中节点值互不相同，因为如果有相同值，则无法唯一确定，但题目没有说明，我们按互不相同处理。
代码：</think>### 已知二叉树先序遍历和中序遍历求后序遍历（C++实现）
#### 核心思路
已知二叉树的先序遍历（根-左-右）和中序遍历（左-根-右）序列，可通过递归方法确定二叉树结构，进而得到后序遍历（左-右-根）：
1. **先序首元素为根节点**
2. **在中序序列中找到根节点位置**
3. **划分左右子树**（左子树长度 = 根节点中序位置 - 中序起始位置）
4. **递归处理左右子树**
5. **最后输出根节点值**（后序遍历特性）
#### C++实现代码
```cpp
#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;
// 递归构建后序遍历序列
void buildPost(vector<int>& pre, vector<int>& in, vector<int>& post,
int preStart, int preEnd, int inStart, int inEnd,
unordered_map<int, int>& inMap) {
if (preStart > preEnd) return; // 递归终止条件
int rootValue = pre[preStart]; // 当前子树根节点值
int rootIndex = inMap[rootValue]; // 根节点在中序序列的位置
int leftSize = rootIndex - inStart; // 左子树节点数量
// 递归构建左子树（先序区间[preStart+1, preStart+leftSize]）
buildPost(pre, in, post, preStart + 1, preStart + leftSize, inStart, rootIndex - 1, inMap);
// 递归构建右子树（先序区间[preStart+leftSize+1, preEnd]）
buildPost(pre, in, post, preStart + leftSize + 1, preEnd, rootIndex + 1, inEnd, inMap);
// 后序遍历：最后存储根节点
post.push_back(rootValue);
}
// 主函数接口
vector<int> getPostorder(vector<int>& preorder, vector<int>& inorder) {
unordered_map<int, int> inMap;
// 建立中序遍历值->位置的映射（O(1)查找）
for (int i = 0; i < inorder.size(); i++) {
inMap[inorder[i]] = i;
}
vector<int> postorder;
buildPost(preorder, inorder, postorder, 0, preorder.size()-1, 0, inorder.size()-1, inMap);
return postorder;
}
// 示例用法
int main() {
vector<int> pre = {3, 9, 20, 15, 7}; // 先序序列
vector<int> in = {9, 3, 15, 20, 7}; // 中序序列
vector<int> post = getPostorder(pre, in);
cout << "后序遍历结果: ";
for (int val : post) cout << val << " "; // 输出: 9 15 7 20 3
return 0;
}
```
#### 关键步骤解析
1. **建立中序索引映射**
使用`unordered_map`存储中序序列的值与位置关系，实现$O(1)$时间复杂度的根节点定位[^1]：
```cpp
unordered_map<int, int> inMap;
for (int i = 0; i < inorder.size(); i++) {
inMap[inorder[i]] = i;
}
```
2. **递归划分子树**
根据左子树长度$k$（$k = \text{rootIndex} - \text{inStart}$）确定子树边界[^2]：
- 左子树先序区间：$[\text{preStart}+1, \text{preStart}+k]$
- 右子树先序区间：$[\text{preStart}+k+1, \text{preEnd}]$
3. **后序序列生成**
递归完成后，按**左子树→右子树→根节点**顺序将根值加入`post`数组：
```cpp
post.push_back(rootValue); // 后序遍历最后访问根
```
#### 复杂度分析
- **时间复杂度**：$O(n)$（每个节点处理一次）
- **空间复杂度**：$O(n)$（哈希表存储中序索引，递归栈深度）
#### 边界条件处理
- 当先序区间为空（`preStart > preEnd`）时终止递归
- 确保中序序列包含所有先序元素（依赖输入有效性）
#### 示例验证
给定：
- 先序：$[3, 9, 20, 15, 7]$
- 中序：$[9, 3, 15, 20, 7]$
输出后序：$[9, 15, 7, 20, 3]$
对应二叉树结构：
```
3
/ \
9 20
/ \
15 7
```
本文介绍了如何利用中序遍历和后序遍历的有序序列来重建二叉树，强调了后序遍历根节点的重要性，并展示了如何通过这两个序列确定节点的左右子树。
扫一扫
483
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
