c语言随机生成数要什么写

在C语言中，可以使用stdlib库中的rand()函数来生成随机数。rand()函数返回一个伪随机整数，范围在0到RAND_MAX之间。为了生成不同的随机数，需要使用srand()函数来设置随机数生成器的种子。通常，可以使用当前时间作为种子，因为每次程序运行时时间都会发生变化，从而生成不同的随机数序列。

以下是一个简单的示例代码，用于生成一个介于0到1之间的随机浮点数：

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

int main() {
    // 设置随机数种子为当前时间
    srand((unsigned int)time(NULL));

    // 生成随机数
    double random_number = (double)rand() / RAND_MAX;

    // 输出随机数
    printf("随机数：%f\n", random_number);

    return 0;
}

在上面的代码中，首先使用time()函数获取当前时间作为种子，然后使用rand()函数生成一个随机整数，并将其转换为浮点数。最后，使用printf()函数输出生成的随机数。每次运行程序时，都会生成不同的随机数序列。

相关问题

c语言代码实现随机一个加权图的建立和prim算法求最小生成树

以下是使用 C 语言实现随机一个加权图的建立和 Prim 算法求最小生成树的代码：

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

#define MAX_VERTICES 100
#define INF INT_MAX

int n; // 图的顶点数
int dist[MAX_VERTICES]; // 存放从已经包含在最小生成树中的顶点到其它顶点的最短距离
int visited[MAX_VERTICES]; // 标记顶点是否已经包含在最小生成树中
int graph[MAX_VERTICES][MAX_VERTICES]; // 存放图的邻接矩阵

void prim(int start) {
    int i, j, k;
    int min;
    int u;

    // 初始化
    for (i = 0; i < n; i++) {
        dist[i] = INF;
        visited[i] = 0;
    }
    dist[start] = 0;

    for (i = 0; i < n; i++) {
        min = INF;
        for (j = 0; j < n; j++) {
            if (!visited[j] && dist[j] < min) {
                min = dist[j];
                u = j;
            }
        }
        visited[u] = 1;
        for (k = 0; k < n; k++) {
            if (!visited[k] && graph[u][k] < dist[k]) {
                dist[k] = graph[u][k];
            }
        }
    }
}

int main() {
    int i, j;

    // 读入图的顶点数和边数
    int m;
    printf("Enter the number of vertices: ");
    scanf("%d", &n);
    printf("Enter the number of edges: ");
    scanf("%d", &m);

    // 初始化随机数种子
    srand(time(NULL));

    // 随机生成边并更新邻接矩阵
    int u, v, w;
    for (i = 0; i < m; i++) {
        u = rand() % n;
        v = rand() % n;
        w = rand() % 100 + 1;
        if (u != v && graph[u][v] == INF) {
            graph[u][v] = w;
            graph[v][u] = w;
        } else {
            i--;
        }
    }

    // 调用 Prim 算法求最小生成树
    prim(0);

    // 输出最小生成树的边权和
    int sum = 0;
    for (i = 0; i < n; i++) {
        sum += dist[i];
    }
    printf("The weight of the minimum spanning tree is %d.\n", sum);

    return 0;
}

在上述代码中，我们首先读入图的顶点数和边数，然后初始化随机数种子。接着，我们使用 `rand()` 函数随机生成边并更新邻接矩阵，其中边的权值为 1 到 100 之间的随机整数。由于是无向图，所以需要更新两个顶点之间的邻接关系。如果生成的边已经存在或者是自环边，则需要重新生成，直到生成一条新的边为止。最后，调用 `prim()` 函数求最小生成树，并输出最小生成树的边权和。

用C语言随机生成任意一个Ascii码文本文件，包含10000个字符。 (1) 文件由小写26个字母生成，至少包含1次自己姓名的小写全拼。 (2) 使用哈夫曼编码压缩和恢复以上文件，计算文件压缩率，同时能够根据压缩文件恢复成源文件。

由于哈夫曼编码需要统计字符出现频率，因此我们需要先生成文本文件。

以下是一个示例代码，生成一个包含10000个字符的文件，其中至少包含一次“wangxiaoming”的小写全拼：

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

int main() {
    srand(time(NULL)); // 初始化随机数种子

    char name[] = "wangxiaoming";
    int name_len = sizeof(name) / sizeof(char) - 1; // 减去末尾的'\0'

    FILE* fp = fopen("random.txt", "w");
    if (fp == NULL) {
        printf("Failed to create file.\n");
        return 1;
    }

    for (int i = 0; i < 10000; i++) {
        char c;
        if (i < 1000 && rand() % 10 == 0) { // 前1000个字符中，有1/10的概率生成姓名
            c = name[rand() % name_len];
        } else {
            c = 'a' + rand() % 26; // 其他字符随机生成小写字母
        }
        fputc(c, fp);
    }

    fclose(fp);
    printf("File created successfully.\n");

    return 0;
}

接下来，我们使用哈夫曼编码对生成的文件进行压缩和恢复。我们可以使用已有的哈夫曼编码库，比如`huffman.h`和`huffman.c`，这里不再赘述。

以下是一个示例代码，使用哈夫曼编码对文件进行压缩和恢复，计算文件压缩率：

#include <stdio.h>
#include <stdlib.h>
#include "huffman.h"

int main() {
    FILE* fp = fopen("random.txt", "r");
    if (fp == NULL) {
        printf("Failed to open file.\n");
        return 1;
    }

    fseek(fp, 0, SEEK_END);
    long size = ftell(fp); // 获取文件大小
    rewind(fp);

    char* buffer = (char*)malloc(size * sizeof(char));
    fread(buffer, sizeof(char), size, fp); // 读取文件内容
    fclose(fp);

    huffman_tree_t* tree = huffman_build_tree(buffer, size); // 构建哈夫曼树
    huffman_table_t* table = huffman_build_table(tree); // 构建哈夫曼编码表

    unsigned char* compressed;
    long compressed_size = huffman_compress(buffer, size, table, &compressed); // 压缩文件

    fp = fopen("compressed.bin", "wb");
    if (fp == NULL) {
        printf("Failed to create compressed file.\n");
        return 1;
    }

    fwrite(compressed, sizeof(unsigned char), compressed_size, fp); // 写入压缩后的文件
    fclose(fp);

    char* decompressed = huffman_decompress(compressed, compressed_size, tree); // 解压文件

    fp = fopen("decompressed.txt", "w");
    if (fp == NULL) {
        printf("Failed to create decompressed file.\n");
        return 1;
    }

    fwrite(decompressed, sizeof(char), size, fp); // 写入解压后的文件
    fclose(fp);

    double compression_ratio = (double)compressed_size / size; // 计算压缩率
    printf("Compression ratio: %.2f\n", compression_ratio);

    free(buffer);
    free(compressed);
    free(decompressed);

    huffman_destroy_tree(tree);
    huffman_destroy_table(table);

    return 0;
}

需要注意的是，由于哈夫曼编码是基于二进制的，因此压缩后的文件需要以二进制方式写入，而不是以文本方式写入。因此在压缩文件写入时，应使用`wb`模式打开文件，而在解压文件写入时，应使用`w`模式打开文件。