【算法 突然被问到怎么将1w次for循环优化】原来这么简单

// 优化后 - 使用数学恒等式
for (int i = 0; i < 10000; i++) {
    double result = std::sin(2 * i) / 2.0;  // 只需一次函数调用
}

// 优化后 - 预计算所有值
std::vector<double> sin_cache(10000);
std::vector<double> cos_cache(10000);

// 预先计算所有三角函数值（只需一次）
for (int i = 0; i < 10000; i++) {
    sin_cache[i] = std::sin(i);
    cos_cache[i] = std::cos(i);
}

// 主循环使用缓存值
for (int i = 0; i < 10000; i++) {
    double result = sin_cache[i] * cos_cache[i];
}

#include <immintrin.h>

// 优化后 - 使用AVX指令集
for (int i = 0; i < 10000; i += 4) {
    // 一次加载4个整数
    __m128i indices = _mm_set_epi32(i+3, i+2, i+1, i);
    
    // 转换为浮点数（需要额外处理）
    __m128 floats = _mm_cvtepi32_ps(indices);
    
    // 计算sin(2x)（实际实现更复杂，这里简化表示）
    __m128 results = fast_sin(_mm_add_ps(floats, floats));
    
    // 除以2
    results = _mm_div_ps(results, _mm_set1_ps(2.0f));
    
    // 存储结果
    _mm_storeu_ps(&output[i], results);
}

// 手动展开（每次循环处理 4 次计算）
for (int i = 0; i < 10000; i += 4) {
    process(i);
    process(i + 1);
    process(i + 2);
    process(i + 3);
}

// 编译器优化（GCC/Clang 使用 `#pragma unroll`）
#pragma unroll(4)
for (int i = 0; i < 10000; i++) {
    process(i);
}

#include <omp.h>
#pragma omp parallel for
for (int i = 0; i < 10000; i++) {
    process(i); // 自动分配到多个线程
}

#include <immintrin.h>
for (int i = 0; i < 10000; i += 8) {
    __m256 data = _mm256_load_ps(input + i);
    __m256 result = _mm256_mul_ps(data, data); // 一次处理 8 个 float
    _mm256_store_ps(output + i, result);
}

// 优化前（跳跃访问）
for (int i = 0; i < 10000; i++) {
    arr[index[i]] = process(i); // index 是随机顺序
}

// 优化后（顺序访问）
std::sort(index.begin(), index.end()); // 先排序
for (int i = 0; i < 10000; i++) {
    arr[index[i]] = process(i);
}

// 优化前（分支预测开销大）
for (int i = 0; i < 10000; i++) {
    if (i % 2 == 0) {
        processA(i);
    } else {
        processB(i);
    }
}

// 优化后（拆分成两个循环）
for (int i = 0; i < 10000; i += 2) {
    processA(i);
}
for (int i = 1; i < 10000; i += 2) {
    processB(i);
}

// 优化前（O(n²)）
for (int i = 0; i < 10000; i++) {
    for (int j = 0; j < 10000; j++) {
        // ...
    }
}

// 优化后（O(n log n)）
std::sort(data.begin(), data.end());
// ...