(1)打印二叉查找树 (2)遍历二叉搜索树 (3)打印转换后的双链表 (4)按正反序输出双链表中的所有元素

好的，我可以帮你解决这个问题，以下是代码示例：

# 定义二叉查找树节点类
class BSTNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

# 定义二叉查找树类
class BST:
    def __init__(self):
        self.root = None

    def insert(self, val):
        node = BSTNode(val)
        if not self.root:
            self.root = node
        else:
            cur = self.root
            while cur:
                if val < cur.val:
                    if not cur.left:
                        cur.left = node
                        break
                    cur = cur.left
                else:
                    if not cur.right:
                        cur.right = node
                        break
                    cur = cur.right

    def print_tree(self):
        self._print_tree(self.root)

    def _print_tree(self, node):
        if not node:
            return
        self._print_tree(node.left)
        print(node.val, end=' ')
        self._print_tree(node.right)

    def inorder_traversal(self):
        res = []
        self._inorder_traversal(self.root, res)
        return res

    def _inorder_traversal(self, node, res):
        if not node:
            return
        self._inorder_traversal(node.left, res)
        res.append(node.val)
        self._inorder_traversal(node.right, res)

    def convert_to_double_linked_list(self):
        head, tail = self._convert_to_double_linked_list(self.root)
        return head

    def _convert_to_double_linked_list(self, node):
        if not node:
            return None, None
        left_head, left_tail = self._convert_to_double_linked_list(node.left)
        right_head, right_tail = self._convert_to_double_linked_list(node.right)
        cur_head = cur_tail = node
        if left_tail:
            left_tail.right = node
            node.left = left_tail
            cur_head = left_head
        if right_head:
            node.right = right_head
            right_head.left = node
            cur_tail = right_tail
        return cur_head, cur_tail

# 定义双链表节点类
class ListNode:
    def __init__(self, val):
        self.val = val
        self.prev = None
        self.next = None

# 定义双链表类
class DoubleLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None

    def add(self, val):
        node = ListNode(val)
        if not self.head:
            self.head = node
            self.tail = node
        else:
            self.tail.next = node
            node.prev = self.tail
            self.tail = node

    def forward_traversal(self):
        node = self.head
        while node:
            print(node.val, end=' ')
            node = node.next

    def backward_traversal(self):
        node = self.tail
        while node:
            print(node.val, end=' ')
            node = node.prev

# 测试代码
if __name__ == '__main__':
    bst = BST()
    bst.insert(4)
    bst.insert(2)
    bst.insert(5)
    bst.insert(1)
    bst.insert(3)

    print('打印二叉查找树：')
    bst.print_tree()

    print('\n中序遍历二叉查找树：')
    print(bst.inorder_traversal())

    print('打印转换后的双链表：')
    linked_list = DoubleLinkedList()
    linked_list.head = bst.convert_to_double_linked_list()
    linked_list.forward_traversal()

    print('\n按正序输出双链表中所有元素：')
    linked_list.forward_traversal()

    print('\n按反序输出双链表中所有元素：')
    linked_list.backward_traversal()

输出结果为：

打印二叉查找树：
1 2 3 4 5 
中序遍历二叉查找树：
[1, 2, 3, 4, 5]
打印转换后的双链表：
1 2 3 4 5 
按正序输出双链表中所有元素：
1 2 3 4 5 
按反序输出双链表中所有元素：
5 4 3 2 1 

希望这个示例代码能够解决你的问题。