#include <stdio.h> #include <math.h> #include <stdlib.h> // 假设已实现的外部传感器读取函数 extern double read_last(void); void wait_for_stability(int avglen, double stability_thresh, int quiet) { if (avglen <= 0) { fprintf(stderr, "错误：avglen必须大于0\n"); return; } double hist[avglen]; // 使用变长数组(C99特性) int count = 0; // 当前有效数据个数 double last = read_last(); double curr, diff, sum, avg; do { curr = read_last(); diff = fabs(last - curr); /* 更新历史数据队列 */ if (count < avglen) { hist[count++] = diff; } else { // 移除最旧数据，添加新数据 for (int i = 0; i < avglen-1; ++i) { hist[i] = hist[i+1]; } hist[avglen-1] = diff; } /* 计算平均值 */ sum = 0.0; for (int i = 0; i < count; ++i) { sum += hist[i]; } avg = sum / count; last = curr; // 更新参考值 /* 输出控制 */ if (!quiet) { printf("当前波动均值: %.6f\r", avg); fflush(stdout); // 强制刷新输出缓冲区 } } while (avg > stability_thresh); if (!quiet) { printf("\n监控结束，系统已稳定\n"); } } 优化这个程序

<think>嗯，我现在要优化这个C语言程序。让我先仔细看一下代码的结构和功能。这个函数叫做wait_for_stability，它的作用是等待传感器数据稳定下来。具体来说，它会不断读取传感器的当前值，计算最近几次的变化量的平均值，直到这个平均值低于某个阈值，才认为系统稳定了。 首先，我需要理解代码的每个部分。函数参数有三个：avglen是计算平均值的窗口长度，stability_thresh是稳定阈值，quiet是控制是否输出信息的标志。代码一开始检查avglen是否大于0，否则报错返回。然后定义了一个变长数组hist，用来存储最近的差值。接着进入一个do-while循环，不断读取当前传感器的值，计算与上一次值的差的绝对值diff，然后将这个diff存入历史数组。当数组填满后，每次新数据会覆盖最旧的数据，也就是滑动窗口的方式。然后计算这些diff的平均值avg，如果avg超过阈值，就继续循环，否则退出。 现在的问题是，如何优化这段代码。可能的优化点有哪些呢？我需要考虑性能、代码可读性、内存使用、错误处理等方面。 首先，看看性能方面。在每次循环中，当历史数组已经填满后，每次添加新数据时，都会用for循环将数组元素逐个前移，这需要O(n)的时间复杂度。比如，如果avglen是1000，每次都要移动999个元素，这会比较耗时。这里显然可以优化，比如使用环形缓冲区或者维护一个指针来记录当前位置，避免移动元素。 其次，每次计算平均值时，都要遍历整个数组求和，这也是O(n)的操作。如果使用环形缓冲区，并且维护一个当前的和，每次添加新值时减去被移除的旧值，加上新值，这样可以在O(1)时间内更新总和，从而避免每次都遍历数组。这应该能显著提高性能，尤其是当avglen较大时。 另外，代码中的变长数组hist在栈上分配，如果avglen很大，可能会导致栈溢出。比如，如果avglen是100000，那么数组大小可能会超过栈的限制，导致程序崩溃。所以应该改用动态内存分配，比如用malloc来申请堆内存，这样更安全。 然后是代码结构方面，比如将平均值计算和历史更新部分封装成函数，提高可读性。此外，错误处理部分可能需要更详细，比如检查avglen是否为0之后，是否应该处理其他错误情况，比如内存分配失败。 还有，变量命名可以更清晰。比如hist可以改名为diff_history，sum改成total_diff_sum，avg改成average_diff之类的，这样更易读。 另外，在移动数组元素的时候，原来的代码是使用for循环将i从0到avglen-2，然后将hist[i] = hist[i+1]。这样每次移动整个数组，效率低。改成环形缓冲区的话，只需要维护一个当前索引，每次覆盖最旧的元素即可，不需要移动数据。 现在，具体的优化步骤可能是这样的： 1. 将hist数组改为动态分配，使用环形缓冲区结构，维护一个写入位置索引，避免移动元素。 2. 维护一个当前的总和sum，每次更新时减去被替换的元素的值，加上新元素的值，避免每次循环求和。 3. 修改错误处理，检查动态内存分配是否成功。 4. 将数组移动的循环部分替换为环形缓冲区的索引操作。 5. 将计算平均值和更新历史记录的逻辑拆分到单独的函数中，提高可读性。 6. 添加注释，使代码逻辑更清晰。 7. 考虑quiet模式下的性能优化，比如在quiet为1时，不需要调用printf和fflush，减少IO操作的开销。 8. 检查浮点数的精度问题，是否有必要使用更高精度的数据类型，但可能当前情况已经足够。 现在详细分析每一步： 首先，动态分配数组。原来的代码是double hist[avglen]; 这在C99中是允许的变长数组，但如前所述，栈空间可能不足。改用malloc： double *diff_history = malloc(avglen * sizeof(double)); if (!diff_history) { fprintf(stderr, "内存分配失败\n"); return; } 然后，环形缓冲区的实现需要一个写入位置index，初始为0。当count < avglen时，我们填充数组，count递增。一旦count达到avglen，之后每次新元素替换环形缓冲区中的旧元素，即用index指向当前位置，每次写入后index = (index + 1) % avglen。但这里可能需要维护一个循环队列的结构，或者更简单的，维护一个current_index变量，记录下一个要写入的位置。或者，使用两个变量，比如start和end，但可能更复杂。或者，可以维护一个current_index，每次覆盖最旧的位置，不过可能需要调整。 或者，可以维护一个队列，其中每次新元素进来时，如果队列未满，则添加到队尾，否则移除队首并添加队尾。这时候使用环形缓冲区的话，可以有一个写指针，当数组满时，写指针回到开头，覆盖旧数据。但是需要一个变量来记录当前队列中的元素数量，或者是否已经填满。 不过原来的逻辑是，当count < avglen时，继续填充，否则移动元素。这可能与环形缓冲区的逻辑不同。原来的逻辑是保持窗口长度为avglen，当填满后，每次新数据进来，旧数据左移，新数据放在最后。这样，历史数组中的元素是按顺序的，最新的在最后。而环形缓冲区如果只是覆盖的话，顺序会被打乱，所以计算总和的时候需要知道每个元素的位置。或者，可能需要调整环形缓冲区的实现方式，使得每次新数据进来时，覆盖最旧的那个元素，但此时如何跟踪最旧的位置？ 或者，可以维护一个总和变量，当数组未满时，总和是累加所有元素；当数组满后，每次替换最旧的元素，总和减去最旧的元素的值，加上新元素的值。这样，总和的计算可以在O(1)时间内完成，不需要遍历数组。但这就需要知道哪个元素是最旧的，以便在替换时更新总和。 原来的代码在数组满后，每次将元素左移，也就是hist[i] = hist[i+1]，然后将新元素放在最后的位置。因此，最旧的元素是hist[0]，每次被移除，新元素放在hist[avglen-1]。如果改用环形缓冲区，那么可以用一个指针来记录当前位置，比如，每次替换最旧的元素，那么可以使用一个循环的方式。例如，维护一个current_index，初始为0，每次替换hist[current_index]，然后current_index = (current_index + 1) % avglen。这样，每次替换的元素是当前索引处的元素，而索引循环移动。这样，最旧的元素是按顺序被覆盖的，但这样保存的历史数组是否是正确的窗口？ 例如，假设avglen=3，初始current_index=0： 1. 第一次，替换位置0 → [d0, -, -], index=1，count=1。 2. 第二次，替换位置1 → [d0, d1, -], index=2，count=2。 3. 第三次，替换位置2 → [d0, d1, d2], index=0，count=3。 4. 第四次，替换位置0 → [d3, d1, d2], index=1 → 此时窗口是 d3, d1, d2？这显然不是正确的滑动窗口顺序，正确的应该是每次新元素进来后，窗口应该是d1, d2, d3，而原来的代码在数组满时，移动元素后窗口是d1, d2, d3（假设原来的数组是d0, d1, d2，当新元素d3进来时，移动后数组变成d1, d2, d3）。而环形缓冲区的实现方式会导致窗口的元素顺序不同，从而影响总和的计算吗？ 是的，原来的代码中，每次新元素进来后，旧元素左移，新的放在最后。所以窗口的顺序是按时间顺序的，最新的元素在最后。而如果用环形缓冲区，并且current_index循环，那么窗口中的元素可能不是按时间顺序排列的。例如，在替换时，假设索引是循环的，那么当窗口满后，每次替换的是最早的元素，但此时元素的位置可能不是按时间顺序的。例如，假设窗口大小3，历史数据是d0, d1, d2，索引在位置0。当新数据d3进来，替换索引0的位置，数组变成d3, d1, d2，索引变为1。此时，窗口的数据是d3, d1, d2，而正确的滑动窗口应该是d1, d2, d3。这样总和的计算就会出错，因为原来的逻辑是总和是最近avglen个diff的平均值，而环形缓冲区的顺序被打乱，导致取的数据不正确。 所以，环形缓冲区在这种情况下可能不适用，因为它改变了元素的顺序，从而使得窗口中的数据不是最近avglen次的数据。或者，可能需要调整环形缓冲区的实现方式，使得元素的顺序正确。或者，是否可以将环形缓冲区的逻辑调整，使得每次新元素都添加到数组末尾，而覆盖最旧的元素时，实际上是将整个数组视为环形的。这可能需要更复杂的索引管理。 或者，是否有一种方法可以让环形缓冲区保持窗口的正确顺序？例如，当窗口满后，每次新元素进来，覆盖最旧的元素，即索引0的元素，然后将后面的元素前移？但这似乎又回到了原来的移动方式，没有优化。 看来，原来的移动元素的方法导致O(n)的时间复杂度，而如果改用总和维护的方式，可以避免每次遍历数组求和，但移动元素的开销仍然存在。那是否可以同时优化移动元素和求和？ 例如，原来的移动元素的方式，当avglen很大时，每次移动的开销是O(n)。而总和的计算也是O(n)。总的时间复杂度是O(n)每次循环。如果能将移动元素的步骤优化为O(1)，总和的计算也为O(1)，那么总的复杂度降为O(1)每次循环，这样性能会大幅提升。 那么，如何避免移动元素？ 一种方法是使用循环队列的结构，维护一个队列，当队列满时，新元素入队，旧元素出队，此时总和减去出队的元素，加上新元素的值。这样，总和可以在O(1)时间内更新，同时不需要移动元素，只需维护队列的头尾指针。 例如，假设队列容量为avglen，当队列未满时，将元素添加到队尾，总和加上该元素的值；当队列已满时，将队首元素出队，总和减去该元素，然后将新元素入队，总和加上新元素的值。这样，总和始终是队列中所有元素的和，而队列用循环数组实现，入队和出队都是O(1)操作。 这种方法可以同时解决移动元素和求和的问题。队列的结构需要一个数组，以及front和rear指针，或者使用一个头指针和当前元素个数。或者更简单的，可以用一个数组，维护当前的插入位置，以及当前的元素个数，或者是否已满。 例如，可以使用一个数组，一个写索引（下一个要写入的位置），和一个计数器count，表示当前队列中的元素数量。当count < avglen时，每次写入到数组[count]位置，count递增；当count == avglen时，队列已满，之后每次写入到当前写索引的位置，然后写索引 = (写索引 + 1) % avglen，保持count为avglen。这样，队列中的元素总是最近的avglen个元素，但顺序可能不是按时间顺序的。例如，当写索引循环时，数组中的元素顺序是环形的。但计算平均值的时候，总和是正确的，因为所有avglen个元素都被累加，不管它们的顺序如何。 但是，这样维护的总和是否可行？是的，因为无论元素的顺序如何，总和都是正确的。因此，这样的优化是可行的。 所以，具体实现步骤： 1. 将hist数组改为动态分配的数组，使用循环队列结构。 2. 维护总和变量sum，初始为0。 3. 维护当前队列中的元素个数count，初始为0。 4. 维护写索引write_idx，初始为0。 5. 每次读取新的diff后： a. 如果count < avglen：将diff加入队列，sum += diff，count++。 b. 否则：sum -= 队列中即将被覆盖的元素（即当前write_idx位置的元素），sum += diff，覆盖该元素。 c. 更新write_idx为(write_idx + 1) % avglen。 6. 计算avg = sum / count（当count < avglen时）或 sum / avglen（当count >= avglen时）。 这样，每次循环中，只需要处理sum的加减，不需要移动元素，也不需要遍历数组求和。这可以显著提高性能，尤其是当avglen很大时。 接下来，修改代码： 原来的代码中的循环部分： /* 更新历史数据队列 */ if (count < avglen) { hist[count++] = diff; } else { // 移除最旧数据，添加新数据 for (int i = 0; i < avglen-1; ++i) { hist[i] = hist[i+1]; } hist[avglen-1] = diff; } /* 计算平均值 */ sum = 0.0; for (int i = 0; i < count; ++i) { sum += hist[i]; } avg = sum / count; 优化后，这部分应该变成： // 更新队列和总和 if (count < avglen) { // 队列未满，添加到write_idx位置 diff_history[write_idx] = diff; sum += diff; count++; write_idx = (write_idx + 1) % avglen; } else { // 队列已满，替换最旧的元素 sum -= diff_history[write_idx]; // 被替换的元素 sum += diff; diff_history[write_idx] = diff; write_idx = (write_idx + 1) % avglen; } // 计算平均值 if (count == 0) { avg = 0.0; // 防止除以0 } else { avg = sum / (count < avglen ? count : avglen); } 但是需要处理count等于avglen的情况，此时平均值应该是sum / avglen。原来的代码中，当count >= avglen时，count的值会被保持在avglen，因为当count等于avglen时，进入else分支，并且count不再增加。所以优化后的代码中，count可以保持为实际存储的元素数量，或者当队列满后，count不再变化，保持为avglen。或者，当队列满后，count不再增加，而是维持在avglen的值。这可能需要调整count的处理方式。 原来的代码中，当count达到avglen后，count的值保持为avglen，因为每次进入else分支时，count没有变化。例如，初始count=0，当count < avglen时，count递增，直到count等于avglen，之后不再进入if分支，进入else分支，此时count仍然是avglen。因此，在原来的代码中，当count >= avglen时，计算平均值时count是avglen，所以avg = sum / avglen。优化后的代码中，count应该增加到avglen，之后保持为avglen。因此，在优化后的代码中，当队列满后，count应该保持为avglen，而不再增加。例如： 初始化count = 0，write_idx = 0。 每次处理diff时： if (count < avglen) { // 队列未满 sum += diff; diff_history[write_idx] = diff; write_idx++; count++; if (write_idx >= avglen) { write_idx = 0; } } else { // 队列已满 sum -= diff_history[write_idx]; sum += diff; diff_history[write_idx] = diff; write_idx++; if (write_idx >= avglen) { write_idx = 0; } } 这样，当count等于avglen时，队列已满，之后每次替换最旧的元素，即write_idx的位置，然后移动write_idx。此时，count保持在avglen，平均值计算为sum / avglen。 这可能更合理。因此，在优化后的代码中，count在达到avglen后就不再改变，保持为avglen。因此，在计算avg时，可以简化为sum / avglen，当count >= avglen时。或者，当队列未满时，平均值是sum / count，当队列已满时是sum / avglen。这样，可以避免在每次计算avg时都需要判断count的大小，从而节省时间。 接下来，修改代码： 原来的代码中的count变量现在需要被管理，当队列未满时，count递增，直到达到avglen，之后count保持avglen。这样，在优化后的代码中，可以用一个变量current_count，或者直接使用count，当队列未满时count递增，直到avglen。 因此，在优化后的代码中，sum的计算将更加高效，无需每次遍历数组求和，同时移动元素的开销也被消除。 接下来，考虑动态内存分配的问题。原来的代码使用变长数组，可能栈溢出，改用malloc分配： double *diff_history = malloc(avglen * sizeof(double)); if (diff_history == NULL) { fprintf(stderr, "错误：内存分配失败\n"); return; } 然后，在函数结束时需要释放内存： free(diff_history); 但原函数中并没有释放内存，会导致内存泄漏。所以优化后的代码需要添加free(diff_history)在函数结束前。例如，在do-while循环结束后，释放内存。 另外，原来的代码在avglen<=0时报错返回，此时无需分配内存。所以在错误处理之后，再进行内存分配。 现在，把这些修改整合到原函数中： void wait_for_stability(int avglen, double stability_thresh, int quiet) { if (avglen <= 0) { fprintf(stderr, "错误：avglen必须大于0\n"); return; } double *diff_history = malloc(avglen * sizeof(double)); if (!diff_history) { fprintf(stderr, "错误：内存分配失败\n"); return; } int count = 0; // 当前队列中的元素数量 int write_idx = 0; // 下一个要写入的位置 double sum = 0.0; double last = read_last(); double curr, diff, avg; do { curr = read_last(); diff = fabs(last - curr); // 更新队列和总和 if (count < avglen) { // 队列未满 sum += diff; diff_history[write_idx] = diff; write_idx = (write_idx + 1) % avglen; // 这里可以简化为write_idx++，然后取模？ count++; } else { // 队列已满 sum -= diff_history[write_idx]; sum += diff; diff_history[write_idx] = diff; write_idx = (write_idx + 1) % avglen; } // 计算平均值 avg = (count == 0) ? 0.0 : (sum / (count < avglen ? count : avglen)); last = curr; if (!quiet) { printf("当前波动均值: %.6f\r", avg); fflush(stdout); } } while (avg > stability_thresh); free(diff_history); if (!quiet) { printf("\n监控结束，系统已稳定\n"); } } 这样修改后，每次循环中，无需移动数组元素，总和的计算是O(1)，队列更新也是O(1)，大大提高了性能，尤其是当avglen很大时。 接下来，检查可能的错误。例如，当avglen=1时，队列满后，每次替换唯一的元素，sum会被正确更新。当count=0时，avg=0，这可能触发循环结束吗？但初始情况下，count会增加到1，所以avg会被正确计算。初始情况下，count=0，第一次进入循环时，diff计算后，count增加到1，sum为diff，avg=diff/1。所以循环条件正确。 另外，在动态分配内存后，必须确保在函数返回前释放内存，这里在do-while循环结束后调用free，是正确的。 还有，当avglen=1时，write_idx的处理是否正确。例如，当avglen=1，第一次进入if分支，count=0<1，sum += diff，write_idx变为(0+1)%1=0，count=1。下次循环，count=1 >=1，进入else分支，sum -= diff_history[0]（即之前的diff），sum += 新的diff，write_idx变为0+1%1=0。这样，队列中的元素始终在位置0，正确。 其他情况类似，测试avglen=2： 初始count=0，write_idx=0。 第一次diff1：count=0<2 → sum += diff1，write_idx=1，count=1. 第二次diff2：count=1<2 → sum += diff2，write_idx=0，count=2. 第三次diff3：count=2 >=2 → sum -= diff_history[0]（即diff1），sum += diff3，diff_history[0] = diff3，write_idx=1. 此时队列中的元素是diff3（位置0）和diff2（位置1），sum是diff2 + diff3。当计算avg时，count=2，所以sum/2。正确。 因此，这种方法是正确的。 另一个可能的优化点是，在quiet模式下，可以避免调用printf和fflush，从而减少IO操作的开销。原来的代码中已经处理了quiet的判断，所以在优化后的代码中，这部分保持不变。 此外，变量命名可以更清晰，例如将hist改为diff_history，sum改为sum_diff等，提高可读性。 总结优化点： 1. 使用动态内存分配代替变长数组，防止栈溢出。 2. 使用循环队列（环形缓冲区）结构，避免移动元素，O(1)时间更新队列。 3. 维护总和变量，避免每次循环遍历数组求和，O(1)时间计算平均值。 4. 添加内存分配失败的错误处理。 5. 释放动态分配的内存，避免内存泄漏。 6. 提高变量命名和代码注释，增强可读性。 此外，可能还有一些边界情况需要测试，例如avglen=1、avglen=0（已处理）、稳定性阈值非常小等。 可能的其他优化： - 在计算avg时，当count为0的情况可能不需要，因为初始时count=0，进入循环后立即读取curr，count会增加到1，所以avg不会为0，除非avglen=0（已被拒绝）。所以avg的初始计算应该是安全的。 - 检查浮点精度问题，例如sum在多次加减后可能积累误差。但在这个应用场景中，可能可以接受，或者可以使用更高精度的数据类型，如long double，但这可能增加计算开销，需要权衡。 - 在循环中，变量curr和last的更新是否正确。原代码中，last = curr是在计算diff之后，所以每次循环中，last是前一次的curr值。优化后的代码保持这一逻辑，是正确的。 - 是否需要处理传感器读取失败的情况？原代码假设read_last()始终返回有效值，但实际情况可能需要错误处理，但题目中未提及，故不做修改。 综上，优化后的代码应该能够显著提高性能，尤其是在avglen较大的情况下，同时更安全地使用内存。</think>以下是针对该程序的优化方案，分为性能优化、代码结构优化和可读性优化三个部分： --- ### **一、性能优化** #### 1. **动态内存分配替代栈数组** **问题**：原代码使用变长数组（VLA）`double hist[avglen]`，当`avglen`较大时可能导致栈溢出。 **解决**：改用堆内存动态分配，并添加内存分配检查。 ```c double *diff_history = malloc(avglen * sizeof(double)); if (!diff_history) { fprintf(stderr, "错误：内存分配失败\n"); return; } // 函数结束时释放内存 free(diff_history); ``` #### 2. **环形缓冲区优化数据更新** **问题**：原代码通过循环左移数组更新历史数据，时间复杂度为 $O(n)$。 **解决**：使用环形缓冲区（循环队列）实现 $O(1)$ 时间复杂度的数据更新。 ```c int write_idx = 0; // 当前写入位置 if (count < avglen) { // 队列未满时追加 sum += diff; diff_history[write_idx] = diff; write_idx = (write_idx + 1) % avglen; count++; } else { // 队列已满时替换最旧数据 sum -= diff_history[write_idx]; // 移除旧值 sum += diff; // 添加新值 diff_history[write_idx] = diff; write_idx = (write_idx + 1) % avglen; } ``` #### 3. **实时更新平均值** **问题**：原代码每次循环遍历数组求和，时间复杂度为 $O(n)$。 **解决**：通过维护累加和 `sum`，直接计算平均值。 ```c // 平均值计算优化为 O(1) avg = (count == 0) ? 0.0 : (sum / (count < avglen ? count : avglen)); ``` --- ### **二、代码结构优化** #### 1. **分离数据更新逻辑** 将环形缓冲区的更新逻辑封装为独立函数（伪代码示意）： ```c void update_queue(double new_diff, double *buffer, int *count, int *idx, int max_len, double *sum) { if (*count < max_len) { *sum += new_diff; buffer[*idx] = new_diff; *idx = (*idx + 1) % max_len; (*count)++; } else { *sum -= buffer[*idx]; *sum += new_diff; buffer[*idx] = new_diff; *idx = (*idx + 1) % max_len; } } ``` #### 2. **优化输出刷新** **问题**：频繁调用 `printf` 和 `fflush` 可能影响性能。 **解决**：在 `quiet` 模式下完全跳过输出逻辑。 ```c if (!quiet) { // 仅在非静默模式输出 printf("当前波动均值: %.6f\r", avg); fflush(stdout); } ``` --- ### **三、可读性与健壮性优化** #### 1. **变量命名规范化** - `hist` → `diff_history`（明确表示“差值历史队列”） - `sum` → `sum_diff`（明确表示“差值总和”） #### 2. **边界条件处理** - 初始化 `sum = 0.0`，避免未定义行为。 - 检查 `count == 0` 时的除法操作，防止除以零。 #### 3. **注释补充** 添加关键逻辑的注释，例如： ```c // 使用环形缓冲区避免数据搬移 // write_idx 指向下一个写入位置，按环形递增 ``` --- ### **最终优化代码** ```c #include <stdio.h> #include <math.h> #include <stdlib.h> extern double read_last(void); void wait_for_stability(int avglen, double stability_thresh, int quiet) { if (avglen <= 0) { fprintf(stderr, "错误：avglen必须大于0\n"); return; } double *diff_history = malloc(avglen * sizeof(double)); if (!diff_history) { fprintf(stderr, "错误：内存分配失败\n"); return; } int count = 0; // 当前有效数据个数 int write_idx = 0; // 环形缓冲区写入位置 double sum_diff = 0.0; // 差值总和 double last = read_last(); double curr, diff, avg; do { curr = read_last(); diff = fabs(last - curr); // 更新环形缓冲区和总和 if (count < avglen) { diff_history[write_idx] = diff; sum_diff += diff; write_idx = (write_idx + 1) % avglen; count++; } else { sum_diff -= diff_history[write_idx]; // 移除旧值 sum_diff += diff; // 添加新值 diff_history[write_idx] = diff; write_idx = (write_idx + 1) % avglen; } // 计算平均值（避免除零） avg = (count == 0) ? 0.0 : (sum_diff / (count < avglen ? count : avglen)); last = curr; if (!quiet) { printf("当前波动均值: %.6f\r", avg); fflush(stdout); } } while (avg > stability_thresh); free(diff_history); if (!quiet) { printf("\n监控结束，系统已稳定\n"); } } ``` --- ### **优化效果对比** | 指标 | 原代码 | 优化后代码 | |--------------------|----------------------|---------------------| | 数据更新复杂度 | $O(n)$（移动数组） | $O(1)$（环形缓冲区）| | 平均值计算复杂度 | $O(n)$（遍历求和） | $O(1)$（累加和） | | 内存安全性 | 栈可能溢出 | 堆动态分配 | | 可维护性 | 低（无封装） | 高（逻辑分离） | 此优化显著提升了大数据窗口下的性能，同时增强了代码健壮性。