二进制搜索树中所有节点的预购后继者

二进制搜索树（Binary Search Tree）是一种常见的数据结构，它是一棵二叉树，满足以下性质：

• 每个节点的键值大于其左子树中任意节点的键值。
• 每个节点的键值小于其右子树中任意节点的键值。
• 左右子树都是二叉搜索树。

对于二叉搜索树中的每个节点，我们可以定义其预购后继者为比该节点键值大的节点中键值最小的节点。下面介绍如何在二叉搜索树中找到每个节点的预购后继者。

算法思想：

以中序遍历的方式遍历二叉搜索树，如果当前节点是某个节点的预购后继者，则该节点右子树的最左侧节点即为该节点的预购后继者。

实现过程：

定义一个函数 get_predecessor(root, node) ，其中 root 表示二叉搜索树的根节点，node 表示待查询节点的指针。函数返回值为节点 node 的预购后继者的指针。

def get_predecessor(root, node):
    """
    在二叉搜索树中查找节点的预购后继者
    :param root: 二叉搜索树的根节点
    :param node: 待查询节点的指针
    :return: 节点 node 的预购后继者的指针
    """
    if node.right_child is not None:
        # 如果节点有右子树，即右子树的最左侧节点即为预购后继者
        return get_leftmost(node.right_child)
    else:
        # 如果节点没有右子树，则向上查找，直到找到第一个祖先节点，其左子树包含该节点
        cur = node
        parent = node.parent
        while parent is not None and parent.right_child == cur:
            cur = parent
            parent = parent.parent
        return parent

其中， get_leftmost 函数用于查找指定节点的子树中最左侧的节点。

def get_leftmost(root):
    """
    在二叉树中查找最左侧的节点
    :param root: 二叉树的根节点
    :return: 最左侧节点的指针
    """
    cur = root
    while cur.left_child is not None:
        cur = cur.left_child
    return cur

要找到二叉搜索树中所有节点的预购后继者，我们可以以中序遍历的方式遍历该树，并对每个节点调用 get_predecessor 函数。

def get_all_predecessors(root):
    """
    在二叉搜索树中获取所有节点的预购后继者
    :param root: 二叉搜索树的根节点
    :return: 字典，键为节点的值，值为预购后继者的值
    """
    result = {}
    stack = []
    cur = root
    while cur is not None or len(stack) != 0:
        if cur is not None:
            stack.append(cur)
            cur = cur.left_child
        else:
            cur = stack.pop()
            result[cur.value] = get_predecessor(root, cur).value if get_predecessor(root, cur) is not None else None
            cur = cur.right_child
    return result

该函数返回一个字典，其中键为每个节点的值，值为相应节点的预购后继者的值。

代码片段：

class Node:
    def __init__(self, value):
        self.value = value
        self.parent = None
        self.left_child = None
        self.right_child = None

def get_predecessor(root, node):
    """
    在二叉搜索树中查找节点的预购后继者
    :param root: 二叉搜索树的根节点
    :param node: 待查询节点的指针
    :return: 节点 node 的预购后继者的指针
    """
    if node.right_child is not None:
        # 如果节点有右子树，即右子树的最左侧节点即为预购后继者
        return get_leftmost(node.right_child)
    else:
        # 如果节点没有右子树，则向上查找，直到找到第一个祖先节点，其左子树包含该节点
        cur = node
        parent = node.parent
        while parent is not None and parent.right_child == cur:
            cur = parent
            parent = parent.parent
        return parent

def get_leftmost(root):
    """
    在二叉树中查找最左侧的节点
    :param root: 二叉树的根节点
    :return: 最左侧节点的指针
    """
    cur = root
    while cur.left_child is not None:
        cur = cur.left_child
    return cur

def get_all_predecessors(root):
    """
    在二叉搜索树中获取所有节点的预购后继者
    :param root: 二叉搜索树的根节点
    :return: 字典，键为节点的值，值为预购后继者的值
    """
    result = {}
    stack = []
    cur = root
    while cur is not None or len(stack) != 0:
        if cur is not None:
            stack.append(cur)
            cur = cur.left_child
        else:
            cur = stack.pop()
            result[cur.value] = get_predecessor(root, cur).value if get_predecessor(root, cur) is not None else None
            cur = cur.right_child
    return result

注意事项：

• 代码中使用了迭代方式实现中序遍历，避免了递归带来的堆栈溢出问题。
• 由于二叉搜索树中节点的键值不一定是唯一的，因此返回的字典中，值为 None 表示该节点没有预购后继者。