二叉搜索树的递归后继函数（Python）

Question

我正在尝试编写一个函数，该函数将在二叉搜索树中找到大于某个给定 x（即 BST 中 x 的后继）的最小值。我使用的 BST 类如下：

class BSTree:
    class Node:
        def __init__(self, val, left=None, right=None):
            self.val = val
            self.left = left
            self.right = right
            
    def __init__(self):
        self.size = 0
        self.root = None

    def add(self, val):
        assert(val not in self)
        def add_rec(node):
            if not node:
                return BSTree.Node(val)
            elif val < node.val:
                return BSTree.Node(node.val, left=add_rec(node.left), right=node.right)
            else:
                return BSTree.Node(node.val, left=node.left, right=add_rec(node.right))
        self.root = add_rec(self.root)
        self.size += 1
    def height(self):
        """Returns the height of the longest branch of the tree."""
        def height_rec(t):
            if not t:
                return 0
            else:
                return max(1+height_rec(t.left), 1+height_rec(t.right))
        return height_rec(self.root)
    
    def pprint(self, width=64):
        """Attempts to pretty-print this tree's contents."""
        height = self.height()
        nodes  = [(self.root, 0)]
        prev_level = 0
        repr_str = ''
        while nodes:
            n,level = nodes.pop(0)
            if prev_level != level:
                prev_level = level
                repr_str += '\n'
            if not n:
                if level < height-1:
                    nodes.extend([(None, level+1), (None, level+1)])
                repr_str += '{val:^{width}}'.format(val='-', width=width//2**level)
            elif n:
                if n.left or level < height-1:
                    nodes.append((n.left, level+1))
                if n.right or level < height-1:
                    nodes.append((n.right, level+1))
                repr_str += '{val:^{width}}'.format(val=n.val, width=width//2**level)
        print(repr_str)

为了我自己对递归的理解，我正在尝试编写一个递归实现，但我遇到了一些麻烦。到目前为止，这是我所拥有的：

def successor(self, x):
     
        def successor_rec(node):  
            if node is None: 
                return None
            if x < node.val:
                if node.left is not None and node.left.val > x: 
                    return successor_rec(node.left)
                else: 
                    return node.val
            else: 
                return successor_rec(node.right)
        
        return successor_rec(self.root)

考虑以下 BST：

t = BSTree()
    for x in [6, 3, 5, 4, 7, 1, 2, 9, 8, 0]:
        t.add(x)
 t.pprint()

                               6                                
               3                               7                
       1               5               -               9        
   0       2       4       -       -       -       8       -    

当我执行t.successor(4) 时，我得到了 6，虽然我想得到 5，它是树中 4 的继承者。我知道问题出现在函数else: return node.val 的部分，尽管我正在努力解决这个问题。

Answer 1

您的if x < node.val 块不正确。例如，即使是node.left.val < x，你仍然应该去寻找node.left 的后继者，因为它可能有一个右子树（node.left.right）。

这里是一个更正：

            if x < node.val:
                attempt = successor_rec(node.left)
                return node.val if attempt is None else attempt