Python每日一题(14)

一 、题目

题目描述

农夫约翰非常认真地对待他的奶牛们的血统。然而他不是一个真正优秀的记帐员。他把他的奶牛 们的家谱作成二叉树，并且把二叉树以更线性的“树的中序遍历”和“树的前序遍历”的符号加以记录而 不是用图形的方法。

你的任务是在被给予奶牛家谱的“树中序遍历”和“树前序遍历”的符号后，创建奶牛家谱的“树的 后序遍历”的符号。每一头奶牛的姓名被译为一个唯一的字母。（你可能已经知道你可以在知道树的两 种遍历以后可以经常地重建这棵树。）显然，这里的树不会有多于 $26$ 个的顶点。

这是在样例输入和样例输出中的树的图形表达方式：

　　　　　　　　 C
　　　　　　   /  \
　　　　　　  /　　\
　　　　　　 B　　  G
　　　　　　/ \　　/
　　　　   A   D  H
　　　　　　  / \
　　　　　　 E   F

附注：

• 树的中序遍历是按照左子树，根，右子树的顺序访问节点；
• 树的前序遍历是按照根，左子树，右子树的顺序访问节点；
• 树的后序遍历是按照左子树，右子树，根的顺序访问节点。

输入格式

第一行一个字符串，表示该树的中序遍历。

第二行一个字符串，表示该树的前序遍历。

输出格式

单独的一行表示该树的后序遍历。

输入输出样例 #1

输入 #1

ABEDFCHG
CBADEFGH

输出 #1

AEFDBHGC

二、分析

  之前我们的二叉树创建的时候，只输入了前序序列，就能获得整棵树，可是这个题目给了前序、中序的序列，我一开始想是不是数据多余了。后来查阅一下知道，之前创建的时候，前序序列中内部用0代表了空结点，所以能完整创建。而这里不同，没说用0代表空节点，只是给了前序、中序遍历的序列，差别就在这里。
  由前序、中序得到后续序列，整个原理十分简单：前序的第一个字母一定是根。然后找到中序中根的对应下标。接下来将中序序列中，以根为中心，分为左右两棵子树。分别对这两棵子树递归就好了。前提是需要找到这两棵子树的前序、中序序列。中序序列其实已经找到了，就是以根为中心，分开的左右两边就是中序的两棵子树。前序的话，也很巧妙，去掉第一个根结点后，从左往右个中序遍历左子树个距离，正好是左子树前序遍历序列。这里的原理还不明确，因为之前做的是选择题，只会找出前序、中序对应的后序序列，但是之间元素的关系没研究过。等明白原理之后再说明一下吧。

三、源代码

  下面的代码是我想用面向对象思想封装起来的，不过内部实现细节有点小问题，主要还是python的面向对象不是很熟悉。

class Solve:
    def __init__(self):
        pass

    def input_data(self):
        self.mid=input().strip()
        self.pre=input().strip()

    def get_back(self):
        root=self.pre[0]
        index=self.mid.index(root)
        left_mid=self.mid[:index]
        right_mid=self.mid[index+1:]
        left_pre=self.pre[1:1+len(left_mid)]
        right_pre=self.pre[1+len(left_mid):]
        left_post=self.get_back(left_mid,left_pre)
        right_post=self.get_back(right_mid,right_pre)
        self.result=left_post+right_post+root

    def print(self):
        print(self.result)

 

  在get_back()函数中，是需要递归的，我们递归时传入的参数是.get_back(left_mid,left_pre)，而在定义时，只有self参数，这是很明显的错误。不过后来我想这么传入参数.get_back(self,self.mid,self.pre)，可是报错了。在get_back()函数中，内部逻辑实现没有问题，就是递归逻辑、面向对象实现方法有些问题。所以带着疑问，我咨询了deepseek，它给出了完美解答，下面我们来看看吧。

四、deepseek解答

class Solve:
    def __init__(self):
        self.mid = None
        self.pre = None
        self.result = None

    def input_data(self):
        self.mid = input().strip()
        self.pre = input().strip()

    def compute_post_order(self):
        self.result = self._build_post(self.mid, self.pre)

    def _build_post(self, mid, pre):
        if not pre:
            return ''
        root = pre[0]
        idx = mid.index(root)
        left_mid = mid[:idx]
        right_mid = mid[idx+1:]
        left_pre = pre[1:1 + len(left_mid)]
        right_pre = pre[1 + len(left_mid):]
        left_post = self._build_post(left_mid, left_pre)
        right_post = self._build_post(right_mid, right_pre)
        return left_post + right_post + root

    def print_result(self):
        print(self.result)

# 使用示例
solver = Solve()
solver.input_data()
solver.compute_post_order()
solver.print_result()

  deepseek将递归函数改为了类内部实现方法，并重新定义了compute_post_order函数，用来进行递归的。先不论内部实现细节正确与否，从结构上来看是完美的。我咨询了deepseek，类中实现递归的话，最好是设为内部方法。提交这个修改后的代码，样例全部通过。

五、总结

  这是第一次用python面向对象来做题，自己写的话，会感觉很混乱，但是经过修改之后， 结构非常清晰。以后打算做题的话，都用面向对象思想来做题吧，提升一下熟练度，这样对后续manim的学习也会有很多帮助。