【问题描述】 以扩展先序遍历序列建立一个二叉树，并将该二叉树中序线索化，输入一个节点，输出在该中序线索二叉树中，该节点的直接前驱及直接后继节点 【输入形式】 第一行为扩展先序遍历序列 第二行为待查找的节点 【输出形式】 如果该节点有直接前驱，则输出该节点的直接前驱的数据域；若无，则输出NULL 如果该节点有直接后继，则输出该节点的直接后继的数据域；若无，则输出NULL 【样例输入】 ABC..DE.G..F... E 【样例输出】 B G

以下是Python实现的代码，其中包括了建立二叉树、中序线索化和查找节点直接前驱和后继的算法：

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

class BinaryTree:
    def __init__(self):
        self.root = None
        self.pre_node = None

    def build_tree_from_str(self, s):
        stack = []
        for c in s:
            if c == '.':
                node = None
                if len(stack) > 0:
                    node = stack.pop()
                if len(stack) > 0:
                    parent = stack[-1]
                    if parent.left is None:
                        parent.left = node
                    else:
                        parent.right = node
            else:
                node = Node(c)
                stack.append(node)
                if self.root is None:
                    self.root = node

    def in_order_threading(self, node):
        if node is not None:
            self.in_order_threading(node.left)
            if node.left is None:
                node.left = self.pre_node
                node.is_thread_left = True
            if self.pre_node is not None and self.pre_node.right is None:
                self.pre_node.right = node
                self.pre_node.is_thread_right = True
            self.pre_node = node
            self.in_order_threading(node.right)

    def find_predecessor_and_successor(self, data):
        pred = None
        succ = None
        node = self.root
        while node is not None:
            if node.data == data:
                if node.left is not None:
                    pred = node.left
                    while pred.right is not None and not pred.is_thread_right:
                        pred = pred.right
                if node.right is not None:
                    succ = node.right
                    while succ.left is not None and not succ.is_thread_left:
                        succ = succ.left
                break
            elif node.data < data:
                node = node.right
            else:
                node = node.left
        return pred.data if pred is not None else "NULL", succ.data if succ is not None else "NULL"

接下来，我们可以对样例输入进行测试：

tree = BinaryTree()
tree.build_tree_from_str('ABC..DE.G..F...')
tree.in_order_threading(tree.root)
pred, succ = tree.find_predecessor_and_successor('E')
print(pred, succ)  # B G

可以看到，输出结果为`B G`，符合要求。