C++怎么实现一个快速傅里叶变换(FFT)_C++信号处理与数值计算算法

快速傅里叶变换（FFT）基于分治思想，采用迭代与位逆序置换实现高效DFT计算。1. 使用std::complex表示复数，利用单位根ω_N^k的周期性加速运算；2. 通过位逆序置换预处理输入，如8点FFT下标重排为[0,4,2,6,1,5,3,7]，确保内存连续访问；3. 迭代实现中，从长度2开始逐层合并，每层用单位根旋转因子更新值，支持原地计算；4. 应用于多项式乘法时，将系数转为频域相乘再逆变换，时间复杂度O(n log n)。

快速傅里叶变换（FFT）是离散傅里叶变换（DFT）的高效算法，广泛用于信号处理、多项式乘法和数值计算。C++中实现FFT通常采用分治思想，最常见的是基于“**迭代+位逆序置换**”的Cooley-Tukey算法。

1. 基本原理与复数支持

FFT处理的是复数序列，因此需要使用std::complex来表示复数。核心是将长度为N（要求N是2的幂）的DFT分解为更小的DFT，利用单位根的周期性和对称性减少计算量。

单位根定义为：ω_N^k = exp(-2πi * k / N)，其中i是虚数单位。

2. 位逆序置换（Bit-reversal Permutation）

递归版FFT自然完成子问题划分，但迭代版需要预先将输入数组按位逆序重排。例如，8点FFT中，下标二进制表示如下：

立即学习“C++免费学习笔记（深入）”；

• 0: 000 → 000: 0
• 1: 001 → 100: 4
• 2: 010 → 010: 2
• 3: 011 → 110: 6
• 4: 100 → 001: 1
• 5: 101 → 101: 5
• 6: 110 → 011: 3
• 7: 111 → 111: 7

重排后顺序为 [0,4,2,6,1,5,3,7]，这样每一层合并都能连续访问内存。

3. 迭代实现FFT

以下是一个完整的C++实现，支持原地计算：

Toolplay

一站式AI应用聚合生成平台

下载

#include 
#include 
#include 
#include 
using namespace std;
using Complex = complex
const double PI = acos(-1);
// 位逆序置换
void bitReverse(vector& a) {
int n = a.size();
int bits = 0;
while ((1 << bits) < n) bits++;
for (int i = 0; i zuojiankuohaophpcn n; i++) {
    int rev = 0;
    for (int j = 0; j zuojiankuohaophpcn bits; j++)
        if (i & (1 zuojiankuohaophpcnzuojiankuohaophpcn j))
            rev |= 1 zuojiankuohaophpcnzuojiankuohaophpcn (bits - 1 - j);
    if (i zuojiankuohaophpcn rev)
        swap(a[i], a[rev]);
}
}
// 快速傅里叶变换（原地迭代版）
void fft(vector& a, bool invert) {
int n = a.size();
bitReverse(a);
for (int len = 2; len zuojiankuohaophpcn= n; len zuojiankuohaophpcnzuojiankuohaophpcn= 1) {
    double angle = 2 * PI / len * (invert ? 1 : -1);
    Complex wlen(cos(angle), sin(angle));

    for (int i = 0; i zuojiankuohaophpcn n; i += len) {
        Complex w(1);
        for (int j = 0; j zuojiankuohaophpcn len / 2; j++) {
            Complex u = a[i + j];
            Complex v = a[i + j + len/2] * w;
            a[i + j] = u + v;
            a[i + j + len/2] = u - v;
            w *= wlen;
        }
    }
}

if (invert) {
    for (Complex& x : a)
        x /= n;
}
}
4. 使用示例：多项式乘法
FFT常用于高效计算两个多项式的卷积（即系数乘法）：
vector multiply(const vector& a, const vector& b) {
    vector fa(a.begin(), a.end()), fb(b.begin(), b.end());
    int n = 1;
    while (n < a.size() + b.size())
        n <<= 1;
fa.resize(n); fb.resize(n);

fft(fa, false);
fft(fb, false);

for (int i = 0; i zuojiankuohaophpcn n; i++)
    fa[i] *= fb[i];

fft(fa, true);

vectorzuojiankuohaophpcndoubleyoujiankuohaophpcn result(n);
for (int i = 0; i zuojiankuohaophpcn n; i++)
    result[i] = round(fa[i].real()); // 取实部并四舍五入

return result;
}
输入两个系数向量，输出它们的卷积结果，时间复杂度从O(n²)降至O(n log n)。
基本上就这些。注意FFT要求长度为2的幂，如果不是可补零扩展。该实现稳定且易于集成到信号处理流程中。