在一段数组中，如何生成不同的随机数 c语言为例

在C语言中，为了在一个数组中生成不同的随机数，你可以结合数组的索引和随机数生成函数`rand()`。这里有一个简单的示例：

#include <stdio.h>
#include <stdlib.h> // 包含 rand 和 srand 函数
#include <time.h>   // 包含 time 函数用于种子初始化

#define ARRAY_SIZE 10 // 定义数组大小
int arr[ARRAY_SIZE]; // 创建一个整型数组

// 为了每次运行程序时生成不同的随机数，我们需要设置一个全局随机数种子
srand(time(0)); // 使用当前时间作为随机种子

void generate_random_array() {
    int i;
    for (i = 0; i < ARRAY_SIZE; i++) {
        // 将随机数限制在数组下标范围内
        arr[i] = rand() % (ARRAY_SIZE + 1); // 避免arr[i]为0的情况
    }
}

int main() {
    generate_random_array(); // 生成随机数并存储到数组中
    for (int i = 0; i < ARRAY_SIZE; i++) {
        printf("arr[%d]: %d\n", i, arr[i]);
    }
    return 0;
}

相关问题

c++数组乱序c++产生随机数

c 数组乱序可以通过生成随机数来实现。常用的算法是使用Fisher-Yates算法(也称为Knuth-Durstenfeld Shuffle算法)。该算法的基本原理是从数组的最后一个元素开始，每次随机选择一个索引，然后将该索引对应的元素与当前位置的元素进行交换。然后继续从剩下的元素中选择一个索引，重复这个过程，直到数组中的所有元素都被遍历一次。这样就完成了数组的乱序。

以下是c语言实现乱序算法的代码示例：

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

void shuffle(int a[], int n) {
    srand(time(NULL));
    for (int i = n - 1; i > 0; i--) {
        int j = rand() % (i + 1);
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

int main() {
    int a[] = {1, 2, 3, 4, 5};
    int n = sizeof(a) / sizeof(a[0]);
    shuffle(a, n);
    for (int i = 0; i < n; i++) {
        printf("%d ", a[i]);
    }
    return 0;
}

这段代码中，我们使用srand函数以系统时间作为种子来初始化随机数生成器。然后通过rand函数生成一个介于0和i之间的随机索引j。然后将a[i]与a[j]进行交换。重复这个过程，直到所有的元素都被遍历一次。

C语言.实现合并排序算法。要排序的整型数组元素可以用随机数生成器生成，运行程序，分别记录对十万，一百万，一千万，五千万个数据排序所用的时间，列出表格显示统计出来的时间。并单独显示一个100个数据的排序结果。

好的，这是一个C语言版本的实现合并排序算法的代码，同样会生成随机的整型数组，并计算排序所用的时间，最后输出排序结果和时间统计表格：

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

void merge(int arr[], int left_start, int left_end, int right_start, int right_end) {
    int i, j, k;
    int left_size = left_end - left_start + 1;
    int right_size = right_end - right_start + 1;
    int left_half[left_size], right_half[right_size];

    for (i = left_start, k = 0; i <= left_end; i++, k++) {
        left_half[k] = arr[i];
    }
    for (j = right_start, k = 0; j <= right_end; j++, k++) {
        right_half[k] = arr[j];
    }

    i = j = 0;
    k = left_start;
    while (i < left_size && j < right_size) {
        if (left_half[i] < right_half[j]) {
            arr[k] = left_half[i];
            i++;
        }
        else {
            arr[k] = right_half[j];
            j++;
        }
        k++;
    }

    while (i < left_size) {
        arr[k] = left_half[i];
        i++;
        k++;
    }

    while (j < right_size) {
        arr[k] = right_half[j];
        j++;
        k++;
    }
}

void merge_sort(int arr[], int start, int end) {
    if (start < end) {
        int mid = (start + end) / 2;
        merge_sort(arr, start, mid);
        merge_sort(arr, mid + 1, end);
        merge(arr, start, mid, mid + 1, end);
    }
}

int* generate_random_array(int n) {
    int* arr = (int*)malloc(n * sizeof(int));
    int i;
    for (i = 0; i < n; i++) {
        arr[i] = rand() % 1000000;
    }
    return arr;
}

int main() {
    srand(time(NULL));
    clock_t start, end;
    double time_used;

    int n_values[] = {100000, 1000000, 10000000, 50000000};
    int n_values_size = sizeof(n_values) / sizeof(n_values[0]);
    int i, j;

    printf("Sorting %d values...\n", n_values[0]);
    int* arr = generate_random_array(n_values[0]);
    start = clock();
    merge_sort(arr, 0, n_values[0] - 1);
    end = clock();
    printf("Sorted array of %d values:\n", n_values[0]);
    for (i = 0; i < 100; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("Time used: %f seconds.\n", time_used);
    free(arr);

    for (j = 1; j < n_values_size; j++) {
        printf("\nSorting %d values...\n", n_values[j]);
        arr = generate_random_array(n_values[j]);
        start = clock();
        merge_sort(arr, 0, n_values[j] - 1);
        end = clock();
        time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
        printf("Time used: %f seconds.\n", time_used);
        free(arr);
    }
    return 0;
}

代码中 `merge` 函数实现了合并操作， `merge_sort` 函数实现了合并排序算法，同样可以生成随机的整型数组。通过 `clock` 函数可以计算出程序运行的时间。我们分别对输入大小为十万、一百万、一千万和五千万的随机数组进行排序，并输出程序运行时间。同时，我们也对一个大小为100的随机数组进行排序，并输出排序结果。

注意，由于合并排序算法的时间复杂度为 $O(n\log n)$，随着输入大小的增加，程序的运行时间增长速度比较慢，但是对于非常大的输入，程序的运行时间也会非常长。因此，如果您的电脑配置较低，可能需要等待一段时间才能看到程序的输出结果。