构成一棵二叉排序树的算法，和在二叉排序树中进行查找

二叉排序树是一种特殊的二叉树，它的左子树上所有节点的值都小于根节点的值，右子树上所有节点的值都大于根节点的值。因此，对于任意一个节点，它的左子树和右子树都是二叉排序树。下面是构成一棵二叉排序树的算法：

1. 创建一个空树。
2. 从根节点开始，对于每个要插入的节点，如果它的值小于当前节点的值，则将它插入到当前节点的左子树中；如果它的值大于当前节点的值，则将它插入到当前节点的右子树中。
3. 重复步骤2，直到所有节点都被插入到树中。

在二叉排序树中进行查找的算法如下：

1. 从根节点开始，如果要查找的值等于当前节点的值，则返回当前节点。
2. 如果要查找的值小于当前节点的值，则在当前节点的左子树中继续查找。
3. 如果要查找的值大于当前节点的值，则在当前节点的右子树中继续查找。
4. 如果查找到了叶子节点仍然没有找到要查找的值，则说明该值不存在于树中。

下面是Python实现二叉排序树的代码示例：

class TreeNode:
    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):
        if not self.root:
            self.root = TreeNode(val)
            return
        node = self.root
        while node:
            if val < node.val:
                if not node.left:
                    node.left = TreeNode(val)
                    return
                node = node.left
            else:
                if not node.right:
                    node.right = TreeNode(val)
                    return
                node = node.right

    def search(self, val):
        node = self.root
        while node:
            if val == node.val:
                return node
            elif val < node.val:
                node = node.left
            else:
                node = node.right
        return None

    def delete(self, val):
        def find_min(node):
            while node.left:
                node = node.left
            return node

        def delete_node(node, val):
            if not node:
                return None
            if val == node.val:
                if not node.left and not node.right:
                    return None
                if not node.left:
                    return node.right
                if not node.right:
                    return node.left
                min_node = find_min(node.right)
                node.val = min_node.val
                node.right = delete_node(node.right, min_node.val)
            elif val < node.val:
                node.left = delete_node(node.left, val)
            else:
                node.right = delete_node(node.right, val)
            return node

        self.root = delete_node(self.root, val)

    def get_avg_search_len(self):
        def get_depth(node):
            if not node:
                return 0
            return max(get_depth(node.left), get_depth(node.right)) + 1

        def get_total_depth(node, depth):
            if not node:
                return 0
            return depth + get_total_depth(node.left, depth + 1) + get_total_depth(node.right, depth + 1)

        total_depth = get_total_depth(self.root, 1)
        node_count = self.get_node_count()
        return total_depth / node_count if node_count else 0

    def get_node_count(self):
        def count_node(node):
            if not node:
                return 0
            return 1 + count_node(node.left) + count_node(node.right)

        return count_node(self.root)