如何在6次斐波那契计算耗时测试中获取最小值与最大值

嘿，我来帮你把这个极值提取的逻辑理清楚！其实核心思路和你想的差不多——要么在循环测试中实时跟踪每种方法的最小、最大耗时，要么先把6次结果存起来再遍历找极值，两种方式都能实现，下面给你具体的实现方案：

方案一：实时跟踪极值（更高效） #

这种方式不用存储所有6次测试结果，每次跑完直接更新当前的最小/最大值，节省内存，适合测试次数多的场景：

代码示例（Windows平台C++） #

#include <iostream>
#include <windows.h>
#include <cmath> // 用于INFINITY

// 示例：两种斐波那契计算方法
long long fibRecursive(int n) {
    if (n <= 1) return n;
    return fibRecursive(n-1) + fibRecursive(n-2);
}

long long fibIterative(int n) {
    if (n <= 1) return n;
    long long a = 0, b = 1, c;
    for (int i = 2; i <= n; i++) {
        c = a + b;
        a = b;
        b = c;
    }
    return b;
}

int main() {
    int targetFib = 30; // 要计算的斐波那契数下标
    const int testTimes = 6; // 重复测试次数

    // 初始化两种方法的极值：最小值设为无穷大，最大值设为0
    double minTimeRecur = INFINITY, maxTimeRecur = 0.0;
    double minTimeIter = INFINITY, maxTimeIter = 0.0;

    for (int i = 0; i < testTimes; i++) {
        // 测试递归方法
        DWORD start = GetTickCount();
        fibRecursive(targetFib);
        DWORD end = GetTickCount();
        double elapsedRecur = (end - start) / 1000.0; // 转换为秒

        // 更新递归方法的极值
        if (elapsedRecur < minTimeRecur) minTimeRecur = elapsedRecur;
        if (elapsedRecur > maxTimeRecur) maxTimeRecur = elapsedRecur;

        // 测试迭代方法
        start = GetTickCount();
        fibIterative(targetFib);
        end = GetTickCount();
        double elapsedIter = (end - start) / 1000.0;

        // 更新迭代方法的极值
        if (elapsedIter < minTimeIter) minTimeIter = elapsedIter;
        if (elapsedIter > maxTimeIter) maxTimeIter = elapsedIter;
    }

    // 输出结果
    std::cout << "计算斐波那契数F(" << targetFib << ")的耗时统计：\n";
    std::cout << "- 递归方法：最小" << minTimeRecur << "秒，最大" << maxTimeRecur << "秒\n";
    std::cout << "- 迭代方法：最小" << minTimeIter << "秒，最大" << maxTimeIter << "秒\n";

    return 0;
}

方案二：存储所有测试结果后找极值 #

如果你需要保留每一次的测试数据，也可以先把6次耗时存入数组，再通过遍历数组找到最小和最大值：

代码片段示例 #

#include <algorithm> // 用于min_element和max_element

// 声明存储耗时的数组
double recurTimes[6];
double iterTimes[6];

// 循环测试并存储结果
for (int i = 0; i < 6; i++) {
    // 递归测试
    DWORD start = GetTickCount();
    fibRecursive(targetFib);
    DWORD end = GetTickCount();
    recurTimes[i] = (end - start) / 1000.0;

    // 迭代测试
    start = GetTickCount();
    fibIterative(targetFib);
    end = GetTickCount();
    iterTimes[i] = (end - start) / 1000.0;
}

// 查找极值
double minTimeRecur = *std::min_element(recurTimes, recurTimes + 6);
double maxTimeRecur = *std::max_element(recurTimes, recurTimes + 6);
double minTimeIter = *std::min_element(iterTimes, iterTimes + 6);
double maxTimeIter = *std::max_element(iterTimes, iterTimes + 6);

注意事项 #

• GetTickCount()的精度是毫秒级，如果你的算法耗时极短（比如小于1毫秒），可能会得到0的结果，这时可以改用精度更高的QueryPerformanceCounter()来计时。
• 初始化极值时，最小值要设成一个足够大的数（比如INFINITY），最大值设成0，这样第一次的耗时就能正确覆盖初始值。

内容的提问来源于stack exchange，提问作者tswiggy