在 Python 中使用字典构建二叉搜索树

Question

我正在尝试在 python 中使用 dict 构建 BST（二叉搜索树）。我不明白为什么我的代码没有向 BST 添加节点。我在这里看到了一个类似的帖子： How to implement a binary search tree in Python? 除了声明一个节点类外，它看起来与我的代码相同，但我想知道为什么我的 dict 实现失败（并希望提高我对在 python 中使用递归传递参数的理解）。

keys = [10,9,2,5,3,7,101,18]
start = {'key': keys[-1], 'val': 1, 'left': None, 'right': None}
def binarySearch(root, node):
# compare keys and insert node into right place
    if not root:
        root = node
    elif node['key'] < root['key']:
        binarySearch(root['left'], node)
    else:
        binarySearch(root['right'], node)

# Now let's test our function and build a BST
while keys:
    key = keys.pop()
    node = {'key': key, 'val': 1, 'left': None, 'right': None}
    binarySearch(start, node)
print(start) # unchanged, hence my confusion. Thx for your time!

=============================================

编辑：这是使它工作的代码！

def binarySearch(root, node):
# compare keys and insert node into right place
    if not root:
        root = node
    elif node['key'] < root['key']:
        if not root['left']: root['left'] = node
        else: binarySearch(root['left'], node)
    else:
        if not root['right']: root['right'] = node
        else: binarySearch(root['right'], node)

以下是我认为幕后发生的事情（为什么一个版本能够添加到 BST 而另一个版本不能）：

在最初的版本中，我们将到达一个递归调用，其中root 仍然指向BST 中的None，但随后root = node 使root 指向node，它与start 完全没有联系，即 BST 本身。然后局部变量被删除，不做任何更改。

在修改后的版本中，我们将避免这种情况，因为当我们添加节点时，例如root['left'] = node。这里root 仍然指向原始BST，因此我们正在修改原始BST 中的key-val 对，而不是让root 指向完全在BST 之外的东西。

Answer 1

#Creted by The Misunderstood Genius
def add_root(e,key):
    ''''
     e is node's name
    key is the node's key search
    '''
    bst=dict()
    bst[e]={'key':key,'P':None,'L':None,'R':None}
    return bst
def root(tree):
   for k,v in tree.items():
       if v['P'] == None:
           return k





def insert(tree, node, key):
    tree[node]={'key':key,'P':None,'L':None,'R':None}
    y =None
    x = root(tree)
    node_key = tree[node]['key']
    while x is not None:
        y=x
        node_root=tree['R']['key']
        if node_key < node_root:
            x=tree[x]['L']
        else:
            x=tree[x]['R']
    tree[node]['P']=y
    if y is not None and node_key< tree[y]['key']:
        tree[y]['L']=node
    else:
        tree[y]['R']=node

    return  tree


def print_all(tree):
   for k,v in tree.items():
       print(k,v)
       print()
'''
Give a root node and key search target 
Returns the name of the node with associated key 
Else None
'''
def tree_search(tree,root, target):
    if root ==None:
        print(" key with node associate not found")
        return root
    if tree[root]['key'] == target:
        return  root
    if target < tree[root]['key']:
        return tree_search(tree,tree[root]['L'],target)
    else:
        return  tree_search(tree,tree[root]['R'],target)

def tree_iterative_search(tree,root,target):


    while root is not  None and tree[root]['key']!=target:

        if target < tree[root]['key']:
            root=tree[root]['L']


        else:
            root=tree[root]['R']


    return root

def minimum(tree,root):
    while tree[root]['L'] is not None:
        root=tree[root]['L']
    return tree[root]['key']






bst=add_root('R',20)

bst=insert(bst,'M',10)
bst=insert(bst,'B',8)
bst=insert(bst,'C',24)
bst=insert(bst,'D',22)
bst=insert(bst,'E',25)
bst=insert(bst,'G',25)
print_all(bst)
print(tree_search(bst,'R',25))
x=tree_iterative_search(bst,'R',25)
print(x)
#print(minimum(bst,'R'))

Answer 2

让我们像 Python 解释器一样运行您的代码。

让我们从第一个电话开始：binarySearch(start, node)

这里的start 是定义在脚本顶部的dict，node 是另一个dict（奇怪的是具有相同的值）。

让我们跳入调用，我们发现自己位于：if not root:，其中root 指的是上面的start，truthy 也是如此，所以这个if 失败了。

接下来我们发现自己位于：elif node['key'] < root['key']:，在这种情况下不是True。

接下来我们传入else:，我们位于：binarySearch(root['right'], node)。

在我们进入第一个递归调用之前，让我们回顾一下调用的参数是什么：来自start 的root['right'] 的值是None，而node 仍然是我们想要的dict插入某处。所以，进入递归调用。

我们再次发现自己位于：if not root:

然而这次root只是指第一个递归调用的第一个参数，从上面的参数回顾我们可以看出root指的是None。

现在None 被认为是falsy，所以这次if 成功了，我们进入下一行。

现在我们在root = node。

这是python中的一个赋值。这意味着python将使用变量root停止引用None并引用node当前引用的任何内容，即dict，它是在while循环中创建的。所以root（这只是一个参数，但你现在可以认为是一个局部变量）指的是dict。

现在发生的事情是我们在第一次递归调用的末尾，这个函数结束了。每当一个函数结束时，所有的局部变量都会被销毁。即root 和node 被销毁。这只是这些变量，而不是它们所指的内容。

现在我们回到第一个调用站点之后，即binarySearch(root['right'], node)之后

我们可以在这里看到参数：root['right'], node 仍然引用它们之前引用的任何内容。这就是为什么你的start 没有改变以及为什么你的程序现在应该处理left 和right 而不是递归的原因。