任务

给定完整二叉树的前遍历和后遍历，返回其有序遍历。

遍历将表示为两个列表，两个列表均包含n个不同的正整数，每个列表唯一地标识一个节点。您的程序可能会采用这些列表，并使用任何合理的I / O格式输出结果顺序遍历。

您可以假设输入是有效的（也就是说，列表实际上表示对某些树的遍历）。

这是code-golf，因此以字节为单位的最短代码获胜。

定义

一个满二叉树是有限的结构节点，这里由唯一的正整数表示。

完整的二叉树是由单个节点组成的叶子：

                                      1

或一个分支，由一个带有两个子树的节点组成（称为左子树和右子树），每个子树又是一个完整的二叉树：

                                      1
                                    /   \
                                  …       …

这是完整的二叉树的完整示例：

                                        6
                                      /   \
                                    3       4
                                   / \     / \
                                  1   8   5   7
                                     / \
                                    2   9

该前序遍历的满二叉树的递归定义如下：

• 包含节点n的叶子的预遍历是列表[ n ]。
• 包含节点n和子树（L，R）的分支的预排序遍历是列表[ n ] +  预排序（L）+  预排序（R），其中+是列表串联运算符。

对于上面的树，就是[6，3，1，8，2，9，9，4，5，7]。

完整二叉树的后遍历定义如下：

• 包含节点n的叶子的后序遍历是列表[ n ]。
• 包含节点n和子树（L，R）的分支的后序遍历是列表后序（L）+  后序（R）+ [ n ]。

对于上面的树，这是[1、2、9、8、3、5、7、4、6]。

在中序遍历满二叉树的递归定义如下：

• 包含节点n的叶子的有序遍历是列表[ n ]。
• 包含节点n和子树（L，R）的分支的有序遍历是列表有序（L）+ [ n ] +  有序（R）。

对于上面的树，这是[1、3、2、8、9、6、5、4、7]。

结论：给定一对列表[6、3、1、8、2、9、4、5、7]（前置）和[1、2、9、8、3、5、7、4、6]（post）作为输入，您的程序应输出[1、3、2、8、9、6、5、4、7]。

测试用例

每个测试用例均采用格式preorder, postorder → expected output。

[8], [8] → [8]
[3,4,5], [4,5,3] → [4,3,5]
[1,2,9,8,3], [9,8,2,3,1] → [9,2,8,1,3]
[7,8,10,11,12,2,3,4,5], [11,12,10,2,8,4,5,3,7] → [11,10,12,8,2,7,4,3,5]
[1,2,3,4,5,6,7,8,9], [5,6,4,7,3,8,2,9,1] → [5,4,6,3,7,2,8,1,9]

Perl，69 66 62 56 53字节

包括+1的 -p

在STDIN上将后置顺序和后置顺序视为由空格分隔的一行（请注意前排和后置的顺序）。节点以唯一字母表示（任何非空格或换行符都可以）。

inpost.pl <<< "98231 12983"

inpost.pl：

#!/usr/bin/perl -p
s%(.)(.)+\K(.)(.+)\3(\1.*)\2%$4$5$3$2%&&redo;s;.+ ;;

使用原始的纯数字格式需要格外小心，以准确识别单个数字并以73个字节为单位

#!/usr/bin/perl -p
s%\b(\d+)(,\d+)+\K,(\d+\b)(.+)\b\3,(\1\b.*)\2\b%$4$5,$3$2%&&redo;s;.+ ;;

用于

inpostnum.pl <<< "11,12,10,2,8,4,5,3,7 7,8,10,11,12,2,3,4,5"

Haskell，84 83字节

(a:b:c)#z|i<-1+length(fst$span(/=b)z),h<- \f->f i(b:c)#f i z=h take++a:h drop
a#_=a

JavaScript（ES6），100字节

f=(s,t,l=t.search(s[1]))=>s[1]?f(s.slice(1,++l+1),t.slice(0,l))+s[0]+f(s.slice(l+1),t.slice(l)):s[0]

I / O包含“安全”字符（例如字母或数字）的字符串。另一种方法，也是100个字节：

f=(s,t,a=0,b=0,c=s.length-1,l=t.search(s[a+1])-b)=>c?f(s,t,a+1,b,l)+s[a]+f(s,t,l+2+a,l+1,c-l-2):s[a]