洛谷P1030（求先序遍历）题解

题目大意：输入树的中序和后序遍历（节点为大写字母），输出先序遍历

二叉树的各种遍历方式的特点。先序遍历是根左右，中序是左根右，后序是左右根。所以，已知中序和后序的话，怎么找出根节点呢？

比如，后序排列的最后一个字符就是整个二叉树的根节点。然后在中序排列中找到这个根节点，就可以把中序分成左子树和右子树两部分。例如，假设中序是BADC，后序是BDCA，那后序的最后一个字符是A，所以根是A。在中序里，A的位置把中序分成B和DC两部分，也就是左子树是B，右子树是DC。然后，对于右子树的中序是DC，对应的后序部分应该是DC的后序。那在后序排列中，如何找到左右子树对应的部分呢？

可能需要递归处理。比如，对于每个子树来说，它的根节点是后序的最后一个元素。然后分割中序，再分别处理左子树和右子树。这样递归下去，每次确定根节点，并处理左右子树。

那具体步骤可能是这样的：

1. 后序的最后一个字符是当前子树的根节点，输出这个根（因为是先序，所以先访问根）。

2. 在中序中找到这个根的位置，分割成左子树的中序和右子树的中序。

3. 根据左子树和右子树的长度，分割后序序列，得到左子树的后序和右子树的后序。

4. 递归处理左子树，然后递归处理右子树。

比如样例输入中的中序是BADC，后序是BDCA。根节点是A。在中序中，左子树是B，右子树是DC。对应的后序中，左子树的后序应该是B？因为后序的结构是左右根，所以左子树的后序应该是整个后序的左部分，长度等于左子树的大小。例如，左子树有1个节点（B），那么左子树的后序应该是后序的前1个字符，也就是B。剩下的DC就是右子树的后序部分？或者可能不是这样？

或者，后序的结构是左子树的后序 + 右子树的后序 + 根。所以，对于整个后序来说，除去最后一个根节点之后，前面的部分分为左子树的后序和右子树的后序。但是如何分割呢？

比如，假设原后序是BDCA，根是A。左子树的大小是1（B），那么左子树的后序应该是B，而右子树的后序是DC。这样分割的话，那么左子树的后序长度等于左子树的节点数。那对于右子树来说，它的后序应该是除去根节点后的后半部分，长度等于右子树的节点数。

所以分割的关键是，根据中序中找到根的位置，确定左子树和右子树的节点数量，然后分割后序序列。例如，左子树有k个节点，那么后序的前k个是左子树的后序，剩下的（除去根后的总长度是k + m，其中m是右子树的数量）中间可能有m个属于右子树的后序。

这样，在递归处理的时候，每次确定根，然后处理左和右。这样就能构造出整个树的结构，或者直接输出先序的结果，而不需要显式构造树的结构。因为先序的顺序是根左右，所以在处理的时候，每次访问根的时候就输出，然后递归处理左子树和右子树即可。

那现在的问题是，如何根据中序和后序来分割子树，并递归处理。比如，假设当前处理的中序区间是in_start到in_end，后序的区间是post_start到post_end。那么根节点是后序的最后一个元素，也就是post_end的位置。然后在中序中找到该根的位置，记为root_pos。那么左子树的节点数目是root_pos - in_start。右子树的数目是 in_end - root_pos。这时候，左子树的中序区间是in_start到root_pos-1，右子树的中序区间是root_pos+1到in_end。对应的后序区间呢？左子树的后序区间应该是post_start到post_start + left_size -1，右子树的后序区间是post_start + left_size到post_end -1。因为后序的结构是左子树的后序 + 右子树的后序 +根。所以当根被去除之后，剩下的部分左子树的后序在前left_size个元素，剩下的属于右子树。

所以，在递归的时候，可以按照这样的分割方式来处理。例如，在样例中，根是A，中序中的位置是1（假设索引从0开始），左子树的大小是1（B），右子树的大小是2（DC）。那么后序中的左子树部分应该是前1个元素，即B，右子树部分是接下来的两个元素吗？原后序是BDCA，去除根A后是BDC。那左子树的大小是1，所以左子树的后序是B，右子树的后序是DC。然后递归处理左子树的中序B和后序B，得到左子树的根是B，没有左右子树。然后处理右子树的中序DC和后序DC。右子树的根是C（因为后序的最后一个元素是C），在中序中找到C的位置，假设是DC的中序是D在左边，C在右边？或者原中序的右子树是DC，即D是左节点，C是根？或者原中序中的右子树是DC，所以中序是D和 C？那对应的后序是DC，所以根是C。此时，在中序中的根位置是1（假设DC的中序索引是0和1），那么左子树的大小是1（D），右子树的大小是0。所以左子树的后序部分是D？这样，左子树的根是D，没有左右子树。所以整个先序的顺序是A B C D？或者样例的输出是ABCD。哦，样例的输出是ABCD。那这样的话，当处理右子树的中序DC时，根是C，左子树是D，右子树为空。所以先序的顺序是C，然后处理左子树D。那整个顺序是A B C D。对，所以输出ABCD。

那如何把这些步骤转化为代码呢？

可以用递归的方法，每次处理当前的子树的中序和后序字符串。函数可以这样设计：

函数参数是中序字符串和后序字符串，输出先序字符串。每次的处理步骤是：

1. 如果后序字符串为空，返回空。

2. 取后序的最后一个字符作为根，输出。

3. 在中序中找到根的位置，分割成左中序和右中序。

4. 根据左中序的长度，分割后序字符串的左后序和右后序。

5. 递归处理左中序和左后序，得到左子树的先序。

6. 递归处理右中序和右后序，得到右子树的先序。

7. 总的先序就是根 + 左子树的先序 + 右子树的先序。

这样，每次递归调用时，处理对应的子树。比如，样例中的情况：

初始时，中序是BADC，后序是BDCA。

根是A。输出A。

在中序中找到A的位置是索引1。左中序是B（长度1），右中序是DC（长度2）。

左后序是后序的前1个字符，即B。右后序是后序的接下来的2个字符，即DC。

递归处理左中序B和后序B：根是B，输出B。左右子树为空。所以左子树的先序是B。

递归处理右中序DC和后序DC：根是C，输出C。在中序中找到C的位置是索引1。左中序是D（长度1），右中序是空。左后序是D。递归处理左中序D和后序D，输出D。所以右子树的先序是C D。

所以总的结果是A B C D，即ABCD。

那这样，递归函数应该能够正确构建先序的字符串。

那现在的问题是如何实现这个分割。比如，如何根据左中序的长度来分割后序字符串？

假设当前的后序字符串是post，长度为n。根是post[-1]。中序中根的位置是k，左中序的长度是k。那么左后序的长度也是k，所以左后序是post[0:k]。右后序是post[k:n-1]，因为总长度是n-1（去掉根之后的长度是n-1），所以右后序的长度是n-1 -k。也就是，右后序的起始位置是k，长度是 (n-1) -k = 右中序的长度（因为右中序的长度是 len - k -1？比如，原中序的长度是 m，分割后左中序长度是k，右中序是 m -k -1。例如，原中序是BADC，长度4。根的位置是1，左中序长度1，右中序长度是4-1-1=2。即 DC的长度是2。所以右后序的长度应该等于右中序的长度，即2。原后序是BDCA，去掉根A后的后序是BDC，长度3。左后序是前1个字符（B），右后序是后两个字符（DC），这正好符合右中序的长度。所以分割后的右后序的长度等于右中序的长度。

所以，后序字符串的处理方式是：

左后序的长度等于左中序的长度，右后序的长度等于右中序的长度。所以，当分割后序时，左后序是前left_len个字符，右后序是剩下的部分。

例如，后序字符串是post_str，去掉根后的字符串是post_str.substr(0, post_str.size()-1)。然后分割为左后序和右后序，左后序的长度等于左中序的长度（k），所以左后序是前k个字符，右后序是后k到结束的字符。

那代码如何实现呢？

比如，在中序字符串in_str中，找到根的位置pos。左中序的长度是pos。右中序的长度是 in_str.size() - pos -1。

对应的后序字符串是 post_str。根是最后一个字符。剩下的字符串是 post_sub = post_str.substr(0, post_str.size()-1). 左后序的长度是 pos，所以左后序是 post_sub.substr(0, pos)，右后序是 post_sub.substr(pos)。

然后递归处理左中序和左后序，得到左子树的先序。处理右中序和右后序，得到右子树的先序。最后合并根+左+右。

那具体到C++的代码，如何处理字符串的切割？

比如，假设当前的中序字符串是inorder，后序是postorder。函数返回先序的字符串。

那么：

string getPreorder(string inorder, string postorder) {

if (postorder.empty()) return "";

char root = postorder.back();

int pos = inorder.find(root);

string left_in = inorder.substr(0, pos);

string right_in = inorder.substr(pos+1);

int left_len = left_in.size();

string left_post = postorder.substr(0, left_len);

string right_post = postorder.substr(left_len, postorder.size() - left_len -1);

// 因为 postorder.size() - left_len -1 是右后序的长度，等于 right_in.size()

string pre_left = getPreorder(left_in, left_post);

string pre_right = getPreorder(right_in, right_post);

return string(1, root) + pre_left + pre_right;

}

这样是否正确？

比如，样例中的情况：

inorder是"BADC"，postorder是"BDCA".

root是A，在inorder中的位置是1.

left_in是 substr(0,1)即 "B"，right_in是 substr(2)即 "DC".

left_len是1.

left_post是 substr(0,1)即 "B".

right_post是 substr(1, 3-1-0)？或者 postorder.substr(left_len, postorder.size()- left_len -1)？

原postorder的长度是4，所以 post_sub是 substr(0,3)即 "BDC".

left_post的长度是1，所以 substr(0,1)是B.

剩下的长度是2，所以 right_post是 substr(1, 2)即 "DC".

是的。所以递归调用处理left_in（B）和 left_post（B），得到pre_left是 "B". 处理right_in（DC）和 right_post（DC），得到pre_right.

处理right_in的情况：

inorder是"DC"，postorder是"DC".

root是C。在inorder中的位置是1.

left_in是 substr(0,1)即 "D"，right_in是 substr(2)即空.

left_len是1.

left_post是 substr(0,1)即 "D".

right_post是 substr(1, 1-1-0)即空。

递归处理left_in（D）和 left_post（D）得到pre_left是 "D".

处理right_in（空）得到空。

所以pre_right是 "C" + "D" + "" = "CD".

所以总的结果是 A + B + CD → ABCD，符合样例。

所以这个递归函数是正确的。

那现在，如何将这个函数转化为C++代码？

需要注意的是，当输入的中序和后序字符串为空时，返回空字符串。同时，每次递归切割字符串是否正确。

此外，在C++中，substr的第二个参数是长度。比如，s.substr(pos, len) 是从pos开始，截取len长度的字符。如果len超过剩余长度，则取到末尾。所以，比如postorder.substr(left_len, postorder.size() - left_len -1)，这里的长度是否正确？

比如，在样例中，处理右子树的后序时，postorder是BDCA，处理后序的右子树部分时，postorder.substr(left_len, ...)中的left_len是1。原postorder的长度是4，所以 left_len是1。所以截取的位置是1，长度是 (4 -1 -1) =2？或者原postorder的长度是4，post_sub是BDC（长度3）。分割为左后序B（长度1），剩下的DC是后两个字符。所以在post_sub中，右后序的起始位置是left_len=1，长度是 right_in.size() =2（因为right_in是DC，长度2）？ 但是 post_sub的长度是3，所以 substr(1,2)会得到 "DC"。所以正确。

所以在代码中，分割右后序的时候，应该用：

string right_post = post_sub.substr(left_len);

或者更准确地说，因为右后序的长度等于right_in.size()，所以不需要显式指定长度，只要从left_len开始截取到末尾即可。因为 post_sub是postorder去掉根后的字符串，其长度是 postorder.size()-1。而 left_len是左子树的大小，那么剩下的部分长度是 (postorder.size()-1) - left_len = right_in.size()。所以 right_post的长度等于right_in.size()。所以可以直接从left_len的位置截取到末尾。

所以，在代码中，可以这样处理：

string post_sub = postorder.substr(0, postorder.size()-1);

string left_post = post_sub.substr(0, left_len);

string right_post = post_sub.substr(left_len);

这样更简单。

那么，修改后的代码：

string getPreorder(string inorder, string postorder) {

if (postorder.empty()) return "";

char root_ch = postorder.back();

string res;

res += root_ch; // 先序的根节点

size_t root_pos = inorder.find(root_ch);

string left_in = inorder.substr(0, root_pos);

string right_in = inorder.substr(root_pos + 1);

int left_len = left_in.length();

string post_sub = postorder.substr(0, postorder.length()-1);

string left_post = post_sub.substr(0, left_len);

string right_post = post_sub.substr(left_len);

res += getPreorder(left_in, left_post);

res += getPreorder(right_in, right_post);

return res;

}

这样是否正确？

比如，样例中的处理：

post_sub是BDC。left_len是1。left_post是B，right_post是DC。正确。

对于右子树的处理，postorder是DC。根是C。在inorder DC中找到C的位置是1。left_in是D。right_in为空。post_sub是D。left_len是1。left_post是D.substr(0,1)即 D。 right_post是 substr(1)即空。递归处理D的后序D，得到D。所以右子树的先序是C+D+空=CD。总的是正确的。

那这样的代码应该能通过样例。

那现在，如何读取输入？

输入有两行，第一行是中序，第二行是后序。比如样例输入是：

BADC

BDCA

对应的中序是"BADC"，后序是"BDCA"。输出是ABCD。

所以，在C++中，读取两行字符串，可以用cin或者getline。需要注意的是，可能有换行符的问题，但题目中的输入都是大写字母组成的字符串，没有空格，所以直接cin即可。

主函数的大体结构：

#include 

#include 

using namespace std;

string getPreorder(string in, string post) {

if (post.empty()) return "";

char root = post.back();

int pos = in.find(root);

string left_in = in.substr(0, pos);

string right_in = in.substr(pos+1);

int left_len = left_in.size();

string post_sub = post.substr(0, post.size()-1);

string left_post = post_sub.substr(0, left_len);

string right_post = post_sub.substr(left_len);

return string(1, root) + getPreorder(left_in, left_post) + getPreorder(right_in, right_post);

}

int main() {

string in, post;

cin >> in >> post;

cout << getPreorder(in, post) << endl;

return 0;

}

这样应该可以解决问题。

测试样例是否正确？

输入：

BADC

BDCA

函数返回 A + getPreorder(B, B) + getPreorder(DC, DC).

getPreorder(B, B): root是B。pos是0。left_in是空。right_in是空。所以 left_post是空，right_post也是空。返回B + "" + "" = B.

getPreorder(DC, DC): root是C。在DC中找C的位置是1。left_in是D。right_in是空。 post_sub是D.substr(0, 1) → D。 left_post是D.substr(0,1) → D。 right_post是空。所以返回C + getPreorder(D, D) + "".

getPreorder(D, D)返回D。所以整个右子树的处理结果是C+D=CD.

所以总的结果是A+B+CD=ABCD，正确。

那这样应该就能解决问题了。那么这道题的解题思路就是通过递归的方法，每次确定根节点，然后分割中序和后序字符串，递归处理左右子树，最后合并结果。关键点在于正确分割后序字符串的左子树部分和右子树部分，这需要根据中序中找到的根节点的位置来确定左右子树的节点数目，从而分割后序。

AC代码：

#include 
#include 
using namespace std;

string getPreorder(string in, string post) {
    if (post.empty()) return "";
    char root = post.back();
    size_t pos = in.find(root);
    string leftIn = in.substr(0, pos);
    string rightIn = in.substr(pos + 1);
    int leftLen = leftIn.size();
    string postSub = post.substr(0, post.size() - 1);
    string leftPost = postSub.substr(0, leftLen);
    string rightPost = postSub.substr(leftLen);
    return string(1, root) + getPreorder(leftIn, leftPost) + getPreorder(rightIn, rightPost);
}

int main() {
    string inOrder, postOrder;
    cin >> inOrder >> postOrder;
    cout << getPreorder(inOrder, postOrder) << endl;
    return 0;
}

然后我们可以尝试优化一下效率，原来的代码使用了递归的方式，通过每次递归分割中序和后序字符串来构建先序排列。这种方法在逻辑上是正确的，但是可能存在一些效率上的问题，尤其是字符串的频繁分割和复制。因为每次递归调用都会创建新的子字符串，当树的深度较大时，可能会产生较多的临时对象，增加内存开销和运行时间。虽然题目中节点数最多是8，这种情况下影响不大，但用户可能想知道是否有更优的方法，或者希望代码更高效、更简洁。

接下来，我们需要考虑优化的方向。可能的优化点包括：

1. **减少字符串的复制操作**：原来的代码中，每次递归都会创建新的子字符串，尤其是substr操作会生成新的字符串。如果能通过传递索引来避免字符串的复制，可能会提高效率。

2. **使用辅助函数传递索引**：将中序和后序的字符串作为引用传递，同时传递当前处理的起始和结束索引，而不是每次都生成子字符串。这样可以避免字符串复制的开销，特别是在处理较大的输入时会更明显。

3. **预存储中序字符的位置**：例如，使用哈希表（如unordered_map）来存储中序序列中每个字符的位置，这样在查找根节点位置时可以快速定位，而不需要每次都调用find函数，这可能对性能有帮助，尤其是当节点较多时。

4. **尾递归优化**：不过C++编译器对尾递归的支持有限，可能不太容易实现，但可以检查是否有递归调用的优化可能。

现在，我需要考虑如何具体实施这些优化。比如，原来的递归函数处理的是整个字符串的substr，现在可以改为传递in和post的原始字符串，以及当前处理的in_start, in_end, post_start, post_end等索引，从而避免生成子字符串。

例如，原函数中的leftIn是in.substr(0, pos)，而rightIn是in.substr(pos+1)。对应的索引范围应该是in_start到pos-1和pos+1到in_end。同样，后序字符串的处理中，postSub是post.substr(0, post.size()-1)，即去掉最后一个字符（根节点）。然后分割左后序和右后序，根据左子树的长度leftLen来确定分割点。

这时候，可以构造一个辅助函数，参数包括中序和后序的字符串引用，以及当前处理的中序的起始结束索引，和后序的起始结束索引。每次递归调用时，计算这些索引的范围，而不需要创建新的子字符串。

此外，对于中序序列中查找根节点的位置，如果提前建立一个字符到索引的映射，可以快速查找，而不是每次调用string::find，这在多次递归时可能更高效。不过，当节点数较少时，这点优化可能不明显，但对于更一般的情况可能有帮助。

另一个可能的优化是，将结果字符串通过引用传递的方式在递归中构建，避免每次拼接字符串时的复制。例如，使用一个string的引用参数，在每次递归时追加字符，而不是返回新的字符串。这样可以减少字符串拼接的开销，因为每次返回string并拼接时，可能会产生临时对象，尤其是在多次递归调用中。

现在，我需要权衡这些优化方法在本题中的适用性。因为题目中的节点数最多是8，所以即使原来的方法也能轻松处理，不会有性能问题。但用户可能希望代码更高效，或者希望了解更优的写法，或者可能是在准备更大的问题时的练习，所以需要考虑更通用的优化方式。

接下来，我需要设计优化后的代码结构。例如，使用索引传递的方式：

void buildPreOrder(string &in, string &post, int in_start, int in_end, int post_start, int post_end, string &result) {

if (post_start > post_end) return;

char root = post[post_end];

result.push_back(root);

int root_pos = findPosition(in, in_start, in_end, root);

int left_size = root_pos - in_start;

buildPreOrder(in, post, in_start, root_pos -1, post_start, post_start + left_size -1, result);

buildPreOrder(in, post, root_pos +1, in_end, post_start + left_size, post_end -1, result);

}

这里，findPosition函数需要实现查找root在in的in_start到in_end范围内的位置。可以预先建立一个哈希表来存储每个字符在中序中的位置，这样查找时只需O(1)时间。或者，在每次调用时遍历中序的当前段来查找，但由于节点数少，可能差异不大。不过，预先建立哈希表会更高效，特别是当节点较多时。

所以，可能的优化步骤包括：

1. 预先构建中序字符的位置映射。

2. 将递归函数改为使用索引，避免字符串分割。

3. 通过传递结果字符串的引用，直接追加字符，减少字符串拼接次数。

现在，具体的实现步骤：

首先，构建中序的位置映射：

unordered_map in_map;
for(int i=0; i

然后在递归函数中，通过该映射快速找到根节点位置。

然后，递归函数参数包括in和post的引用，当前处理的in和post的起始结束索引，以及结果字符串的引用。

这样，每次递归只需要计算索引，不需要处理子字符串，从而减少内存操作。

此外，结果字符串通过引用传递，每次找到根节点后直接push_back到结果中，这样避免了递归返回时的字符串拼接，因为原来的代码是返回root + left + right，这会创建多个临时字符串对象，而通过引用传递的方式，直接在结果中追加字符，效率更高。

这样优化后，代码的运行时间和内存使用应该会更优，尤其是在节点较多的情况下。对于本题的小数据可能不明显，但代码结构更高效。

现在，我需要将这些思路转化为具体的代码。

例如，主函数中读取输入后，构建in_map，然后调用递归函数，传递索引和结果字符串。

可能的代码结构如下：

#include 

#include 

#include 

using namespace std;

void buildPre(string &in, string &post, int in_start, int in_end, int post_start, int post_end, unordered_map &in_map, string &result) {

if (post_start > post_end) return;

char root = post[post_end];

result.push_back(root);

int root_idx = in_map[root];

int left_size = root_idx - in_start;

buildPre(in, post, in_start, root_idx -1, post_start, post_start + left_size -1, in_map, result);

buildPre(in, post, root_idx +1, in_end, post_start + left_size, post_end -1, in_map, result);

}

int main() {

string in, post;

cin >> in >> post;

unordered_map in_map;

for(int i=0; i

这个代码避免了字符串的切割，通过索引和预先建立的哈希表来快速定位根节点位置。同时，结果字符串通过引用传递，直接追加字符，减少中间字符串的生成。

但是，需要注意的是，原题中的中序和后序可能包含重复字符吗？不过题目中说“树结点用不同的大写字母表示”，所以每个字符唯一，哈希表的键不会有冲突。

这样，这个优化后的代码应该更高效，尤其是在处理较大的输入时。对于本题的小输入，可能差别不大，但结构更优。

可能的进一步优化是，将in和post作为const引用传递，避免不必要的复制。例如，函数参数改为const string &in和const string &post，这样更高效。

另外，递归函数的参数较多，但这是为了传递索引范围。这是可以接受的，因为递归的深度最多为树的高度，即对于n=8的情况，最多递归8层。

总结，优化后的代码通过减少字符串切割和使用索引，以及预存中序位置，提高了效率，尤其是在较大的输入情况下。

优化后的完整代码：

#include 
#include 
#include 
using namespace std;

void buildPre(const string &in, const string &post, 
              int in_start, int in_end, 
              int post_start, int post_end,
              unordered_map& in_map, 
              string& result) {
    if (post_start > post_end) return;
    
    char root = post[post_end];
    result.push_back(root);
    
    int root_idx = in_map[root];
    int left_size = root_idx - in_start;
    
    // 递归处理左子树
    buildPre(in, post, 
            in_start, root_idx - 1,
            post_start, post_start + left_size - 1,
            in_map, result);
    
    // 递归处理右子树
    buildPre(in, post,
            root_idx + 1, in_end,
            post_start + left_size, post_end - 1,
            in_map, result);
}

int main() {
    string in_order, post_order;
    cin >> in_order >> post_order;
    
    unordered_map in_map;
    for (int i = 0; i < in_order.size(); ++i)
        in_map[in_order[i]] = i;
    
    string pre_order;
    buildPre(in_order, post_order, 
            0, in_order.size()-1,
            0, post_order.size()-1,
            in_map, pre_order);
    
    cout << pre_order << endl;
    return 0;
}

这个优化代码通过减少字符串复制和使用索引来提高效率