如何从二进制结构中递归提取

Question

我在 Python 中有这个类：

class PointInfo(object):

    def __init__(self, pnt, vect, src1, src2, fun):

        self.point = pnt
        self.vector = vect
        self.src1 = src1
        self.src2 = src2
        self.func = fun

我创建了一个列表（imp_list），该列表的每个元素都是 PointInfo 类型的对象，source1 或 source2 可以引用某个基点（以“Original”开头）或者它们包含前一个元素的索引这个列表在那个元素的帮助下我们创建了这个对象。

每个对象的构建都像（source1 function source2）函数是一些布尔运算，现在我想追溯每个点并找出每个点的来源直到到达基点。

例如，如果我有一个这样的列表：

如果我想追溯点 0 的来源，它必须给我：(Ori1 & Ori2)

或者第 1 点的来源必须给我：(Ori3 | (Ori1 & Ori2))

或者第 2 点的出处必须给我：(Ori4 ^ (Ori1 & Ori2))

或者第 3 点的出处必须给我：(Ori5 & (Ori3 | (Ori1 & Ori2)))

等等，如何借助python实现呢？

Answer 1

您只需使用@user2963623 给出的递归过程执行深度优先搜索。递归的重要部分是：

1. 确定基本情况

2. 参数如何通过递归调用改变

3. 当前关卡结束时我们返回上一层的结果是什么

在您的特定情况下，给定一个点 x，您可以继续跟踪 src1 或 src2 或两者的“链接”，直到到达“原点”

1.基本情况：

如果src1 和src2 都以'origin' 开头，则返回它

2。递归探索

'src1' 如果它有一个到其他点的'链接'

或“src2”，如果它有一个到其他点的“链接”

或 'src1' 和 'src2' 如果两者都具有指向其他点的“链接”

Answer 2

这是实现它的一种方法：

def trace_source(point):
    if str(point.src1).startswith("Ori") and str(point.src2).startswith("Ori"):
        return '('+point.src1+' '+str(point.func)+' '+point.src2+')'
    elif str(point.src1).startswith("Ori") and not str(point.src2).startswith("Ori"):
        return '('+point.src1+' '+str(point.func)+' '+trace_source(imp_list[point.src2])+')'
    elif not str(point.src1).startswith("Ori") and str(point.src2).startswith("Ori"):
        return '('+trace_source(imp_list[point.src1])+' '+str(point.func)+' '+point.src2+')'
    else:
        return '('+trace_source(imp_list[point.src1])+' '+str(point.func)+' '+trace_source(imp_list[point.src2])+')'

这是基本思想。您可能需要根据数据结构稍微调整代码。

编辑

我使用您给定的类使用以下列表测试了您的代码：

imp_list = []
imp_list.append(PointInfo(None, None, "Ori1", "Ori2", "&"))
imp_list.append(PointInfo(None, None, 0, "Ori3", "|"))
imp_list.append(PointInfo(None, None, 0, "Ori4", "^"))
imp_list.append(PointInfo(None, None, 1, "Ori5", "&"))
imp_list.append(PointInfo(None, None, 3, "Ori6", "&"))

for point in imp_list:
    print  trace_source(point)

结果是：

(Ori1 & Ori2)
((Ori1 & Ori2) | Ori3)
((Ori1 & Ori2) ^ Ori4)
(((Ori1 & Ori2) | Ori3) & Ori5)
((((Ori1 & Ori2) | Ori3) & Ori5) & Ori6)

所以，显然这会起作用。