Algorithm 需要帮助查找二叉搜索树中两个节点之间路径的最大值吗

我试图解决以下问题

在这个问题中，我得到了一个插入到二元搜索树中的值列表，然后给出了另外2个值。起始节点和结束节点。在这些值之间，我需要找到最大值（包括起始节点和结束节点）

示例-4,7,8,6,3

启动节点3

结束节点-7

给定值列表的二进制搜索树

所以路径是3->4->7，最大值是7

我尝试的是创建一个函数查找，它在树中查找数据并返回其父级。我需要做的是反复调用查找函数返回的值，并将父级的值附加到另一个列表中。同时从结束节点调用查找，并将其父级附加到同一个列表中。此操作需要直到相同的值被添加到列表中。一旦发生这种情况，我们知道它们有共同的祖先，并且路径是完整的

以下是我到目前为止所做的尝试

class Node:
def __init__(self,data):
    self.data=data
    self.left=None
    self.right=None

def Insert_BTreeNode(self,data):
    if self.data:
        if data<self.data:
            if self.left is None:
                self.left=Node(data)
            else:
                self.left.Insert_BTreeNode(data)

        elif data>self.data:
            if self.right is None:
                self.right=Node(data)

            else:
                self.right.Insert_BTreeNode(data)

    else:
        self.data=data

def Lookup(self,data,parent=None):

    if data<self.data:
        if self.left is None:
            return None,None
        return self.left.Lookup(data,self)
    elif data>self.data:
        if self.right is None:
            return None,None
        return self.right.Lookup(data,self)
    else:
        if (parent is not None):
            print(parent.data)
        return (parent)

def next_parent(self,Lookup):
    something=Lookup(Lookup)
    return something

b_tree=list(map(int,input().split()))

x,y=map(int,input().split())

root=Node(b_tree[0])

b_treepath=[]

for i in range(1,len(b_tree)):
    root.Insert_BTreeNode(b_tree[i])

z=root.Lookup(x)
a=root.next_parent(z.data)

类节点：
定义初始化（自身，数据）：
self.data=data
self.left=无
self.right=无
def Insert_b绿色节点（自身，数据）：
如果是自助数据：
如果是dataself.data：
如果self.right为无：
self.right=节点（数据）
其他：
self.right.Insert_BTreeNode（数据）
其他：
self.data=data
def查找（自身、数据、父项=无）：
如果是dataself.data：
如果self.right为无：
返回None，None
返回self.right.Lookup（数据，self）
其他：
如果（父项不是无）：
打印（父数据）
返回（父级）
def next_父级（自我，查找）：
something=查找（Lookup）
归还某物
b_tree=list（映射（int，input（）.split（））
x、 y=map（int，input（）.split（））
根=节点（b_树[0]）
b_treepath=[]
对于范围（1，len（b_树））中的i：
root.Insert_BTreeNode（b_树[i]）
z=根。查找（x）
a=根。下一个父项（z.data）

---

解决此问题的帮助得到了广泛的赞赏。

只需对您的好代码做一些小改动：

class Node:
    def __init__(self, data):
        self.data=data
        self.left=None
        self.right=None

    def Insert_BTreeNode(self, data):
        if self.data:
            if data<self.data:
                if self.left is None:
                    self.left=Node(data)
                else:
                    self.left.Insert_BTreeNode(data)

            elif data>self.data:
                if self.right is None:
                    self.right=Node(data)
                else:
                    self.right.Insert_BTreeNode(data)
        else:
            self.data=data

    def Lookup(self, data, parent=None):
        '''
        returns data and parent
        '''
        #print "In Lookup", self.data, data
        if data<self.data:
            if self.left is None:
                #print "left lookup and data", self.left, data
                return None,None
            return self.left.Lookup(data, parent=self)
        elif data>self.data:
            if self.right is None:
                #print "right lookup and data", self.right, data
                return None,None
            return self.right.Lookup(data, parent=self)
        else:
            if (parent is not None):
                print "parent of", data, "is", parent.data, parent 
            return (parent)

    def next_parent(self,Lookup):
        something=self.Lookup(Lookup)
        return something

#b_tree=list(map(int,input().split()))
b_tree = [4,1,3,2,10,8,6,7,11]
#x,y=map(int,input().split())
x, y = 11, 7
root=Node(b_tree[0])
b_treepath=[]
for i in range(1,len(b_tree)):
    root.Insert_BTreeNode(b_tree[i])

#z=root.Lookup(7)
#print z, z.data
#a=root.next_parent(z.data)
#print a

x_ = [x]
y_ = [y]
xP = root.Lookup(x)
yP = root.Lookup(y)

# finding parents till root node for both
while(xP):
    x_.append(xP.data)
    xP = root.next_parent(xP.data)
while(yP):
    y_.append(yP.data)
    yP = root.next_parent(yP.data)
print x_, y_
# finding lowest common ancestor
b_treepath=[]
x_ = x_[::-1]
y_ = y_[::-1]
l = min(len(x_), len(y_))
for i in range(l):
    if x_[i]!=y_[i]:
        break
# (i-1)th position has LCA
x_ = x_[i-1:]
y_ = y_[i-1:]
#answer
print x_, y_
print max(max(x_), max(y_))

类节点：
定义初始化（自身，数据）：
self.data=data
self.left=无
self.right=无
def Insert_b绿色节点（自身，数据）：
如果是自助数据：
如果是dataself.data：
如果self.right为无：
self.right=节点（数据）
其他：
self.right.Insert_BTreeNode（数据）
其他：
self.data=data
def查找（自身、数据、父项=无）：
'''
返回数据和父项
'''
#打印“查找中”、self.data、data
如果是dataself.data：
如果self.right为无：
#打印“右查找和数据”，self.right，data
返回None，None
返回self.right.Lookup（数据，父项=self）
其他：
如果（父项不是无）：
打印“父项”，数据，“是”，父项。数据，父项
返回（父级）
def next_父级（自我，查找）：
something=self.Lookup（查找）
归还某物
#b_tree=list（映射（int，input（）.split（））
b_树=[4,1,3,2,10,8,6,7,11]
#x、 y=map（int，input（）.split（））
x、 y=11,7
根=节点（b_树[0]）
b_treepath=[]
对于范围（1，len（b_树））中的i：
root.Insert_BTreeNode（b_树[i]）
#z=根。查找（7）
#打印z，z数据
#a=根。下一个父项（z.data）
#打印
x_uz=[x]
y_uu=[y]
xP=根目录。查找（x）
yP=根查找（y）
#查找两个节点的父节点到根节点
而（xP）：
附加（xP.data）
xP=根目录下一个父目录（xP.data）
而（yP）：
y.追加（yP.数据）
yP=根目录下一个父目录（yP.data）
打印x_uuy_
#寻找最低共同祖先
b_treepath=[]
x_u=x_[：-1]
y=y[：-1]
l=最小值（len（x_uu），len（y_u））
对于范围（l）中的i：
如果x_[i]=y_[i]：
打破
#（i-1）第四个职位具有LCA
x_uux=x_uui[i-1:]
y=y[i-1:]
#答复
打印x_uuy_
打印最大值（最大值（x），最大值（y））

---

注意：我的工作环境是Python2.7，所以请注意打印语句。

i已脱离循环，因此我们无法访问x_和y_元素，这些元素是-x_u=x_[i-1:]y_=y_[i-1:]代码在我的系统上运行良好。什么东西不适合你？另外，请注意“Python中的作用域单元是一个函数”，并阅读关于for控制变量作用域的讨论：我将再次尝试该代码并让您知道。该代码生成正确的输出，即给定路径上的最大值，对吗？为什么你一次又一次地用不同的值重新初始化x和y变量。为什么不一起使用不同的变量呢？因为审美是个人的选择：）对我来说，任务是尽快帮助你编写工作脚本。那你就更清楚了！让我们一起在这里学习。这里的深度是惊人的。我自己就是个傻瓜！