c语言产生0-100随机数函数时产生一堆数字

你可能是使用了rand()函数来产生随机数，但是它只能产生一个介于0到RAND_MAX（通常是32767）之间的伪随机整数。如果你想要产生0到100之间的随机数，可以使用以下代码：

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

int main()
{
    int num;
    srand(time(NULL)); // 使用当前时间作为种子
    num = rand() % 101; // 产生0到100之间的随机数
    printf("%d\n", num);
    return 0;
}

这里使用了srand()函数来初始化随机数生成器，使用time()函数返回当前时间作为种子。然后使用rand()函数来产生伪随机数，使用取余运算符来限制产生的数字在0到100之间。

相关问题

用c语言设计和实现内部排序算法效率比较平台，通过随机数函数生成无序的数据动态演示各排序算法的排序过程和计算效率。具体要求：详细比较“直接插入、希尔、直接选择、堆、冒泡、快速、归并，基数排序”等排序算法。完成两个功能：1）通过随机数函数生成15个（0-99）的整数，在系统里通过选择不同的排序算法进行演示并显示每一趟的排序结果，同时给出排序算法的关键字比较次数和移动次数；2）通过随机数函数生成100000个（0-9999）的整数，同时输出各排序算法的具体计算时间。

好的，这是一个比较复杂的问题，需要分步骤来回答。首先，我们需要了解每种排序算法的基本原理和实现方式。然后，我们需要设计和实现一个内部排序算法效率比较平台，通过随机数函数生成无序的数据动态演示各排序算法的排序过程和计算效率。最后，我们需要进行效率比较并输出计算时间。

1. 排序算法

常见的内部排序算法有以下几种：

- 直接插入排序
- 希尔排序
- 直接选择排序
- 堆排序
- 冒泡排序
- 快速排序
- 归并排序
- 基数排序

这些算法中，有些是稳定排序，有些是不稳定排序；有些是原地排序，有些是非原地排序；有些时间复杂度较低，有些时间复杂度较高。我们需要了解每种算法的特点，才能选择最适合我们需求的算法。

2. 内部排序算法效率比较平台

设计和实现一个内部排序算法效率比较平台，需要考虑以下几个方面：

- 生成随机数：我们需要使用随机数函数生成无序的数据。在 C 语言中，可以使用 rand() 函数来生成随机数。
- 排序算法的实现：我们需要编写每种排序算法的实现代码。
- 排序算法的演示：我们需要动态演示每种排序算法的排序过程，并显示每一趟的排序结果。
- 计算效率：我们需要记录每种排序算法的关键字比较次数和移动次数，并输出各排序算法的具体计算时间。

3. 效率比较和计算时间输出

效率比较和计算时间输出是我们最终的目标。我们需要使用相同的数据集对每种算法进行测试，并记录每种算法的关键字比较次数和移动次数。然后，我们需要使用 clock() 函数来计算每种算法的计算时间，并输出结果。

总之，完成这个项目需要一定的编程技能和算法基础。我们需要仔细分析问题，设计合理的解决方案，并进行代码实现。

用C语言编写完成直接插入、冒泡、直接选择、快速、堆、归并等排序算法，并根据运行时间比较各种排序算法的运行速度。采用随机数发生器产生待排序整型数据，值的范围在0到n*10之间，排序长度默认20000，编写各种排序程序记录运行速度并做对比分析。1.定义待排序表的长度为n。 2.初始化随机数发生器，产生n个随机数构成的顺序表。 3.创建输出排序表函数，取得系统时间函数，直接插入排序函数，冒泡排序函数，快速排序函数，直接选择排序函数，筛选函数，对排序函数，归并排序函数。 4.主程序调用各个排序函数，输出各排序算法对长度为n的顺序表进行排序所耗费的时间。

以下是C语言实现各种排序算法并比较运行时间的代码：

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

#define LENGTH 20000
#define MAX_VALUE LENGTH*10

void printArray(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int temp = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > temp) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = temp;
    }
}

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

int partition(int arr[], int left, int right) {
    int pivot = arr[left];
    while (left < right) {
        while (left < right && arr[right] >= pivot) {
            right--;
        }
        arr[left] = arr[right];
        while (left < right && arr[left] <= pivot) {
            left++;
        }
        arr[right] = arr[left];
    }
    arr[left] = pivot;
    return left;
}

void quickSort(int arr[], int left, int right) {
    if (left < right) {
        int pivotIndex = partition(arr, left, right);
        quickSort(arr, left, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, right);
    }
}

void heapify(int arr[], int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    if (left < n && arr[left] > arr[largest]) {
        largest = left;
    }
    if (right < n && arr[right] > arr[largest]) {
        largest = right;
    }
    if (largest != i) {
        int temp = arr[i];
        arr[i] = arr[largest];
        arr[largest] = temp;
        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }
    for (int i = n - 1; i >= 0; i--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        heapify(arr, i, 0);
    }
}

void merge(int arr[], int left, int mid, int right, int temp[]) {
    int i = left;
    int j = mid + 1;
    int k = 0;
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    while (i <= mid) {
        temp[k++] = arr[i++];
    }
    while (j <= right) {
        temp[k++] = arr[j++];
    }
    k = 0;
    while (left <= right) {
        arr[left++] = temp[k++];
    }
}

void mergeSort(int arr[], int left, int right, int temp[]) {
    if (left < right) {
        int mid = (left + right) / 2;
        mergeSort(arr, left, mid, temp);
        mergeSort(arr, mid + 1, right, temp);
        merge(arr, left, mid, right, temp);
    }
}

int main() {
    int arr[LENGTH];
    srand(time(NULL));
    for (int i = 0; i < LENGTH; i++) {
        arr[i] = rand() % MAX_VALUE;
    }

    printf("Original array:\n");
    // printArray(arr, LENGTH);

    printf("\nInsertion sort:\n");
    clock_t start = clock();
    insertionSort(arr, LENGTH);
    clock_t end = clock();
    printf("Time: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
    // printArray(arr, LENGTH);

    printf("\nBubble sort:\n");
    start = clock();
    bubbleSort(arr, LENGTH);
    end = clock();
    printf("Time: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
    // printArray(arr, LENGTH);

    printf("\nSelection sort:\n");
    start = clock();
    selectionSort(arr, LENGTH);
    end = clock();
    printf("Time: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
    // printArray(arr, LENGTH);

    printf("\nQuick sort:\n");
    start = clock();
    quickSort(arr, 0, LENGTH - 1);
    end = clock();
    printf("Time: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
    // printArray(arr, LENGTH);

    printf("\nHeap sort:\n");
    start = clock();
    heapSort(arr, LENGTH);
    end = clock();
    printf("Time: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
    // printArray(arr, LENGTH);

    printf("\nMerge sort:\n");
    int temp[LENGTH];
    start = clock();
    mergeSort(arr, 0, LENGTH - 1, temp);
    end = clock();
    printf("Time: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
    // printArray(arr, LENGTH);

    return 0;
}

以上代码中，我们定义了一个包含20000个随机数的数组，值的范围在0到200000之间。然后分别调用各种排序算法，并记录它们的运行时间。最后输出各个排序算法对数组进行排序所花费的时间。可以通过修改LENGTH的值来改变数组的长度。注意，当LENGTH非常大时，排序算法的运行时间会非常长，需要耐心等待。

这里我们使用了clock()函数来获取程序运行的CPU时间，然后计算出各个排序算法的运行时间。请注意，这里的运行时间只是一个参考，实际的运行时间可能会受到多种因素的影响，例如系统负载、硬件配置等。因此，这里的运行时间仅供参考，不代表绝对的准确性。