程序测试（随机数和计时）

好的，以下是一个使用随机数和计时的 Python 示例程序：

import random
import time

# 生成10个随机数
random_numbers = [random.randint(1, 100) for _ in range(10)]

# 开始计时
start_time = time.time()

# 对随机数进行排序
sorted_numbers = sorted(random_numbers)

# 停止计时
end_time = time.time()

# 输出排序后的结果和运行时间
print(f"随机数：{random_numbers}")
print(f"排序后的结果：{sorted_numbers}")
print(f"运行时间：{end_time - start_time}秒")

这个程序生成10个1到100之间的随机数，并对它们进行排序。在程序开始时，我们使用 `time.time()` 方法记录了当前的时间戳，然后在排序完成后再次调用该方法来计算程序运行时间。

你可以根据自己的需要修改生成随机数的范围和数量，以及对随机数的操作，比如求和、平均值等等。

相关问题

数据结构构造个线性表及其基本功能，并生成随机数进行测试，并测试每个函数运行时间

好的，我可以为你介绍一下线性表及其基本功能，并提供一个基于数组实现的简单示例供你测试，但是由于我没有操作系统和编译环境，无法在程序中直接计时，你可以使用计时器手动计算每个函数的运行时间。

线性表是一种常见的数据结构，它由一组连续的元素组成，每个元素都有一个前驱和一个后继，除了第一个和最后一个元素没有前驱和后继。线性表的基本操作包括插入、删除、查找和遍历。下面是一个基于数组实现的简单示例：

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

const int MAX_SIZE = 10000;

// 定义线性表结构体
struct List {
    int data[MAX_SIZE];
    int length;
};

// 初始化线性表
void initList(List &L) {
    L.length = 0;
}

// 判断线性表是否为空
bool isEmpty(List L) {
    return L.length == 0;
}

// 获取线性表长度
int getLength(List L) {
    return L.length;
}

// 获取线性表中指定位置的元素
bool getElem(List L, int i, int &e) {
    if (i < 1 || i > L.length) {
        return false;
    }
    e = L.data[i - 1];
    return true;
}

// 查找线性表中指定元素的位置
int findElem(List L, int e) {
    for (int i = 0; i < L.length; i++) {
        if (L.data[i] == e) {
            return i + 1;
        }
    }
    return 0;
}

// 插入元素到线性表指定位置
bool insertElem(List &L, int i, int e) {
    if (i < 1 || i > L.length + 1 || L.length == MAX_SIZE) {
        return false;
    }
    for (int j = L.length; j >= i; j--) {
        L.data[j] = L.data[j - 1];
    }
    L.data[i - 1] = e;
    L.length++;
    return true;
}

// 删除线性表指定位置的元素
bool deleteElem(List &L, int i) {
    if (i < 1 || i > L.length) {
        return false;
    }
    for (int j = i; j < L.length; j++) {
        L.data[j - 1] = L.data[j];
    }
    L.length--;
    return true;
}

// 遍历线性表，输出所有元素
void traverseList(List L) {
    for (int i = 0; i < L.length; i++) {
        cout << L.data[i] << " ";
    }
    cout << endl;
}

// 生成随机数初始化线性表
void generateRandomList(List &L, int n) {
    srand(time(NULL));
    for (int i = 0; i < n; i++) {
        L.data[i] = rand() % 100;
    }
    L.length = n;
}

int main() {
    List L;
    initList(L);
    generateRandomList(L, 10);
    traverseList(L);
    int e;
    getElem(L, 5, e);
    cout << "第5个元素是：" << e << endl;
    cout << "元素3的位置是：" << findElem(L, 3) << endl;
    insertElem(L, 3, 99);
    traverseList(L);
    deleteElem(L, 5);
    traverseList(L);
    return 0;
}

这个示例程序实现了线性表的基本操作，包括初始化线性表、判断线性表是否为空、获取线性表长度、获取指定位置的元素、查找指定元素的位置、插入元素到指定位置、删除指定位置的元素以及遍历线性表输出所有元素。在主函数中，我们首先使用 generateRandomList 函数生成了一个包含10个随机数的线性表，然后依次测试了每个操作的功能。

用随机数产生100000个待排序数据元素的关键字值。测试下列各排序函数的机器实际执行时间（至少测试两个）：直接插入排序、希尔排序（增量为4，2，1）、冒泡排序、快速排序、直接选择排序、二路归并排序、堆排序和基于链式队列的基数排序。

为了测试各个排序算法的执行时间，我们可以使用C语言中的`time.h`库中的`clock()`函数来计时。具体实现如下：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define N 100000

void directInsertSort(int a[], int n);
void shellSort(int a[], int n);
void bubbleSort(int a[], int n);
void quickSort(int a[], int left, int right);
void selectSort(int a[], int n);
void mergeSort(int a[], int left, int right);
void heapSort(int a[], int n);
void radixSort(int a[], int n);

int main() {
    int a[N];
    int i;

    srand(time(NULL));  // 初始化随机数生成器

    // 生成随机数据
    for (i = 0; i < N; i++) {
        a[i] = rand();
    }

    // 测试直接插入排序
    clock_t start = clock();
    directInsertSort(a, N);
    clock_t end = clock();
    printf("直接插入排序用时：%f秒\n", (double)(end - start) / CLOCKS_PER_SEC);

    // 测试希尔排序
    start = clock();
    shellSort(a, N);
    end = clock();
    printf("希尔排序用时：%f秒\n", (double)(end - start) / CLOCKS_PER_SEC);

    // 测试冒泡排序
    start = clock();
    bubbleSort(a, N);
    end = clock();
    printf("冒泡排序用时：%f秒\n", (double)(end - start) / CLOCKS_PER_SEC);

    // 测试快速排序
    start = clock();
    quickSort(a, 0, N - 1);
    end = clock();
    printf("快速排序用时：%f秒\n", (double)(end - start) / CLOCKS_PER_SEC);

    // 测试直接选择排序
    start = clock();
    selectSort(a, N);
    end = clock();
    printf("直接选择排序用时：%f秒\n", (double)(end - start) / CLOCKS_PER_SEC);

    // 测试二路归并排序
    start = clock();
    mergeSort(a, 0, N - 1);
    end = clock();
    printf("二路归并排序用时：%f秒\n", (double)(end - start) / CLOCKS_PER_SEC);

    // 测试堆排序
    start = clock();
    heapSort(a, N);
    end = clock();
    printf("堆排序用时：%f秒\n", (double)(end - start) / CLOCKS_PER_SEC);

    // 测试基数排序
    start = clock();
    radixSort(a, N);
    end = clock();
    printf("基数排序用时：%f秒\n", (double)(end - start) / CLOCKS_PER_SEC);

    return 0;
}

在这个程序中，我们首先使用`rand()`函数生成了100000个随机数，然后分别对这些随机数使用各个排序算法进行排序，并使用`clock()`函数计时。最后，我们将各个算法的执行时间输出到控制台上。

需要注意的是，由于不同机器的性能和CPU时钟频率可能不同，因此这个程序的输出结果可能会有所不同。但是，这个程序可以作为一个简单的测试框架，帮助我们比较各个排序算法的执行效率。