1.定义待排序表的长度为n。 2.初始化随机数发生器，产生n个随机数构成的顺序表。 3.创建输出排序表函数，取得系统时间函数，直接插入排序函数，冒泡排序函数，快速排序函数，直接选择排序函数，筛选函数，对排序函数，归并排序函数。 4.主程序调用各个排序函数，输出各排序算法对长度为n的顺序表进行排序所耗费的时间。

非常感谢您的问题，根据您的要求，我不会透露您的任何要求，并且我会尽力回答您的问题。

针对您的问题，我可以给出一个基本的排序算法实现过程：

1. 定义待排序表的长度为n。
2. 初始化随机数发生器，产生n个随机数构成的顺序表。
3. 创建输出排序表函数，取得系统时间函数，直接插入排序函数，冒泡排序函数，快速排序函数，直接选择排序函数，筛选函数，对排序函数，归并排序函数。
4. 主程序调用各个排序函数，输出各排序算法对长度为n的顺序表进行排序所耗费的时间。

下面是一个简单的Python实现：

import random
import time

# 生成长度为n的随机数列表
def generate_random_list(n):
    return [random.randint(0, 1000) for _ in range(n)]

# 输出排序后的列表
def print_sorted_list(sort_func, lst):
    print(f"排序前：{lst}")
    start_time = time.time()  # 记录开始时间
    sorted_lst = sort_func(lst)  # 调用排序函数进行排序
    end_time = time.time()  # 记录结束时间
    print(f"排序后：{sorted_lst}")
    print(f"排序耗时：{end_time - start_time:.6f}s")

# 直接插入排序
def insertion_sort(lst):
    for i in range(1, len(lst)):
        key = lst[i]
        j = i - 1
        while j >= 0 and lst[j] > key:
            lst[j+1] = lst[j]
            j -= 1
        lst[j+1] = key
    return lst

# 冒泡排序
def bubble_sort(lst):
    for i in range(len(lst)):
        for j in range(len(lst)-i-1):
            if lst[j] > lst[j+1]:
                lst[j], lst[j+1] = lst[j+1], lst[j]
    return lst

# 快速排序
def quick_sort(lst):
    if len(lst) <= 1:
        return lst
    else:
        pivot = lst[0]
        left_lst = [x for x in lst[1:] if x <= pivot]
        right_lst = [x for x in lst[1:] if x > pivot]
        return quick_sort(left_lst) + [pivot] + quick_sort(right_lst)

# 直接选择排序
def selection_sort(lst):
    for i in range(len(lst)):
        min_idx = i
        for j in range(i+1, len(lst)):
            if lst[j] < lst[min_idx]:
                min_idx = j
        lst[i], lst[min_idx] = lst[min_idx], lst[i]
    return lst

# 堆排序
def heap_sort(lst):
    def heapify(lst, n, i):
        largest = i
        l = 2 * i + 1
        r = 2 * i + 2

        if l < n and lst[l] > lst[largest]:
            largest = l

        if r < n and lst[r] > lst[largest]:
            largest = r

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

    n = len(lst)

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

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

    return lst

# 归并排序
def merge_sort(lst):
    if len(lst) <= 1:
        return lst
    else:
        mid = len(lst) // 2
        left_lst = merge_sort(lst[:mid])
        right_lst = merge_sort(lst[mid:])
        return merge(left_lst, right_lst)

def merge(left_lst, right_lst):
    i, j = 0, 0
    merged_lst = []
    while i < len(left_lst) and j < len(right_lst):
        if left_lst[i] <= right_lst[j]:
            merged_lst.append(left_lst[i])
            i += 1
        else:
            merged_lst.append(right_lst[j])
            j += 1
    merged_lst += left_lst[i:]
    merged_lst += right_lst[j:]
    return merged_lst

if __name__ == '__main__':
    lst = generate_random_list(10)
    print_sorted_list(insertion_sort, lst)
    print_sorted_list(bubble_sort, lst)
    print_sorted_list(quick_sort, lst)
    print_sorted_list(selection_sort, lst)
    print_sorted_list(heap_sort, lst)
    print_sorted_list(merge_sort, lst)

以上是一个基本的排序算法实现过程，您可以根据需要对其进行修改和完善。同时，请注意在实际使用中需要考虑算法的时间复杂度和空间复杂度等因素，选择合适的排序算法来解决实际问题。