代码 1) 实现有序表的查找。 2) 用二叉链表作为存储结构，输入键值序列建立一棵二叉排序树，然后中序遍历这棵二叉树。 3) 分别用堆排序及快速排序算法，对待排序记录进行排序并输出排序结果。

1) 有序表的查找可以使用二分查找算法，前提是有序表已经按照一定的顺序排好了。可以参考以下代码实现：

def binary_search(arr, low, high, x):
    if high >= low:
        mid = (high + low) // 2
        if arr[mid] == x:
            return mid
        elif arr[mid] > x:
            return binary_search(arr, low, mid - 1, x)
        else:
            return binary_search(arr, mid + 1, high, x)
    else:
        return -1

arr = [2, 3, 4, 10, 40]
x = 10

result = binary_search(arr, 0, len(arr) - 1, x)

if result != -1:
    print(f"元素在索引 {result} 处")
else:
    print("元素不在数组中")

2) 二叉排序树（BST）是一种二叉树，它的左子树中的所有节点的值都小于根节点的值，而右子树中的所有节点的值都大于根节点的值。可以参考以下代码实现：

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def insert_node(root, node):
    if root is None:
        root = node
    else:
        if root.val < node.val:
            if root.right is None:
                root.right = node
            else:
                insert_node(root.right, node)
        else:
            if root.left is None:
                root.left = node
            else:
                insert_node(root.left, node)

def inorder_traversal(root):
    if root:
        inorder_traversal(root.left)
        print(root.val)
        inorder_traversal(root.right)

arr = [5, 3, 7, 2, 4, 6, 8]

root = Node(arr[0])
for i in range(1, len(arr)):
    insert_node(root, Node(arr[i]))

inorder_traversal(root)

3) 堆排序和快速排序都是常用的排序算法。堆排序使用堆这种数据结构，通过将待排序的序列构造成一个大根堆或小根堆来实现排序。快速排序则是通过分治法来实现排序，通过选择一个基准元素将待排序序列分割成两部分，一部分比基准元素小，一部分比基准元素大，然后递归地对这两部分进行排序。可以参考以下代码实现：

堆排序：

def heapify(arr, n, i):
    largest = i
    l = 2 * i + 1
    r = 2 * i + 2

    if l < n and arr[i] < arr[l]:
        largest = l

    if r < n and arr[largest] < arr[r]:
        largest = r

    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

def heap_sort(arr):
    n = len(arr)

    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)

    for i in range(n - 1, 0, -1):
        arr[0], arr[i] = arr[i], arr[0]
        heapify(arr, i, 0)

arr = [12, 11, 13, 5, 6, 7]
heap_sort(arr)
print(arr)

快速排序：

def partition(arr, low, high):
    i = low - 1
    pivot = arr[high]

    for j in range(low, high):
        if arr[j] < pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]

    arr[i + 1], arr[high] = arr[high], arr[i + 1]
    return i + 1

def quick_sort(arr, low, high):
    if low < high:
        pi = partition(arr, low, high)

        quick_sort(arr, low, pi - 1)
        quick_sort(arr, pi + 1, high)

arr = [10, 7, 8, 9, 1, 5]
n = len(arr)
quick_sort(arr, 0, n - 1)
print(arr)