得到某一个区间内的随机数算法cpp

在C++中，你可以通过`<random>`库中的随机数生成器和分布来生成一个区间内的随机数。下面是一个例子，展示了如何生成一个指定区间内的随机整数：

#include <random>
#include <iostream>

int main() {
    // 创建随机数生成器
    std::random_device rd;
    std::mt19937 gen(rd()); // 以随机设备作为种子

    // 定义随机数的范围，例如 [min, max]
    int min = 10; // 区间的最小值
    int max = 20; // 区间的最大值

    // 创建均匀分布
    std::uniform_int_distribution<> dis(min, max);

    // 生成随机数
    int random_number = dis(gen);
    std::cout << "随机数是: " << random_number << std::endl;

    return 0;
}

在这个例子中，`std::random_device`用来提供一个非确定性的随机种子，然后用这个种子初始化`std::mt19937`，即Mersenne Twister随机数生成器。`std::uniform_int_distribution<>`用于生成指定范围内的均匀分布的随机整数。调用`dis(gen)`将返回一个在这个范围内的随机数。

相关问题

3. 假定一维整型数组a[n]中的每个元素值均在[0,200]区间内，用C++函数编写一个算法，分别统计出落在[0,20]，[21,50]，[51,80]，[81,130]，[131,200]等各区间内的元素个数用随机函数完成

在C++中，你可以通过遍历数组并使用条件判断来实现这个功能。首先，你需要包含必要的头文件，并创建一个计数数组来存储每个区间的元素数量。然后，使用`std::random_device`和`std::mt19937`生成随机数，模拟输入的一维整型数组。以下是一个简单的示例：

#include <iostream>
#include <vector>
#include <random>

int main() {
    const int n = 100; // 假设数组长度为100
    int a[n];          // 初始化数组

    // 使用Mersenne Twister引擎生成随机数
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, 200);  // 0到200的均匀分布

    // 分别填充数组
    for (int i = 0; i < n; ++i) {
        a[i] = dis(gen);
    }

    // 计算每个区间的元素个数
    std::vector<int> count(5, 0);  // 初始化计数器，大小为5表示5个区间
    for (int num : a) {
        if (num >= 0 && num <= 20)
            count[0]++;
        else if (num > 20 && num <= 50)
            count[1]++;
        else if (num > 50 && num <= 80)
            count[2]++;
        else if (num > 80 && num <= 130)
            count[3]++;
        else if (num > 130 && num <= 200)
            count[4]++;
    }

    // 输出结果
    std::cout << "各区间的元素个数分别为:\n";
    for (int i = 0; i < 5; ++i) {
        std::cout << "[" << i * 21 << ", " << (i + 1) * 21 - 1 << "] 区间有: " << count[i] << " 个元素\n";
    }

    return 0;
}

实现合并排序算法。要排序的整型数组元素可以用随机数生成器生成，运行程序，分别记录对十万，一百万，五千万，一千万个数据排序所用的时间，列出表格显示统计出来的时间。并单独显示一个100个数据的排序结果。用C++编写，完整且正确的输出代码，写上完整的注释

#include <iostream>
#include <vector>
#include <chrono> // 需要用到高精度时间测量
#include <random> // 随机数生成器

// 合并排序函数，使用分治策略
template<typename T>
void mergeSort(T arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2; // 找到中间点
        // 分别对左右半部分进行递归排序
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);

        // 合并两个已排序的部分
        merge(arr, left, mid, right);
    }
}

// 合并函数，将两个已排序区间合并回原数组
template<typename T>
void merge(T arr[], int left, int mid, int right) {
    int leftSize = mid - left + 1;
    int rightSize = right - mid;

    T* leftArr = new T[leftSize]; // 左半部分临时数组
    T* rightArr = new T[rightSize]; // 右半部分临时数组

    // 将左、右两边的元素复制到临时数组
    for (int i = 0; i < leftSize; ++i)
        leftArr[i] = arr[left + i];
    for (int j = 0; j < rightSize; ++j)
        rightArr[j] = arr[mid + 1 + j];

    // 按顺序将较小元素放入原数组
    int i = 0, j = 0, k = left;
    while (i < leftSize && j < rightSize) {
        if (leftArr[i] <= rightArr[j]) {
            arr[k++] = leftArr[i++];
        } else {
            arr[k++] = rightArr[j++];
        }
    }

    // 如果有剩余元素，则直接复制未遍历完的那一边
    while (i < leftSize)
        arr[k++] = leftArr[i++]; // 左边剩余
    while (j < rightSize)
        arr[k++] = rightArr[j++]; // 右边剩余

    // 释放临时数组
    delete[] leftArr;
    delete[] rightArr;
}

// 生成随机数组
std::vector<int> generateRandomArray(int size, std::default_random_engine& generator) {
    std::uniform_int_distribution<int> distribution(0, 10000); // 0-10000范围内的随机数
    std::vector<int> arr(size);
    for (int& num : arr)
        num = distribution(generator);
    return arr;
}

// 记录和打印排序时间
void measureAndPrint(const std::string& title, const std::vector<int>& data) {
    auto start = std::chrono::high_resolution_clock::now();
    mergeSort(data.data(), 0, data.size() - 1);
    auto end = std::chrono::high_resolution_clock::now();
    double time_used = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() * 1e-6; // 微秒转换为秒

    std::cout << "Sorted " << title << ": Time taken: " << time_used << " seconds\n";
    std::cout << "Sorted array: ";
    for (const auto& num : data) {
        std::cout << num << ' ';
    }
    std::cout << "\n";
}

int main() {
    std::random_device rd;
    std::mt19937 gen(rd()); // 使用Mersenne Twister随机数生成器
    std::uniform_int_distribution<> distr(0, 100000000); // 0-1亿范围内的随机数

    // 不同规模的数据排序时间测量
    const int sizes[] = {100000, 1000000, 5000000, 10000000};
    std::vector<int> arr[4]; // 用于存储不同大小的数组
    for (size_t i = 0; i < sizeof(sizes) / sizeof(sizes[0]); ++i) {
        arr[i] = generateRandomArray(sizes[i], gen);
        measureAndPrint("Data with " + std::to_string(sizes[i]) + " elements", arr[i]);
    }

    // 单独显示100个数据的排序结果
    std::vector<int> smallArr(100);
    for (auto& num : smallArr)
        num = distr(gen);
    measureAndPrint("Small Data with 100 elements", smallArr);

    return 0;
}

这段代码首先定义了一个`mergeSort`函数用于执行归并排序，然后创建了一个`generateRandomArray`函数用于生成指定长度的随机整数数组。`measureAndPrint`函数负责记录排序时间和打印结果。在`main`函数中，我们生成了不同数量级的数据（10万、100万、500万和1000万）并计算排序所需时间。