C语言：斐波那契数列

斐波那契数列：

斐波那契数列是一个经典的数学问题，定义为：F(0)=0，F(1)=1，F(n)=F(n-1)+F(n-2)（n≥2）

 1. 递归方法

#include <stdio.h>

int fibonacci_recursive(int n) {
    if (n <= 1) {
        return n;
    }
    return fibonacci_recursive(n-1) + fibonacci_recursive(n-2);
}

int main() {
    int n = 10;
    printf("Fibonacci(%d) = %d\n", n, fibonacci_recursive(n));
    return 0;
}

特点：代码简洁，但效率低，时间复杂度O(2^n)，存在大量重复计算。

2. 迭代方法

#include <stdio.h>

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

int main() {
    int n = 10;
    printf("Fibonacci(%d) = %d\n", n, fibonacci_iterative(n));
    return 0;
}

特点：效率高，时间复杂度O(n)，空间复杂度O(1)。

3. 动态规划方法（带记忆化）

#include <stdio.h>
#include <stdlib.h>

int fibonacci_dp(int n) {
    if (n <= 1) {
        return n;
    }
    
    int *dp = (int*)malloc((n+1) * sizeof(int));
    dp[0] = 0;
    dp[1] = 1;
    
    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i-1] + dp[i-2];
    }
    
    int result = dp[n];
    free(dp);
    return result;
}

int main() {
    int n = 10;
    printf("Fibonacci(%d) = %d\n", n, fibonacci_dp(n));
    return 0;
}

特点：时间复杂度O(n)，空间复杂度O(n)，但可以优化空间复杂度。

4. 优化的动态规划方法

#include <stdio.h>

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

int main() {
    int n = 10;
    printf("Fibonacci(%d) = %d\n", n, fibonacci_dp_optimized(n));
    return 0;
}

特点：与迭代方法相同，时间复杂度O(n)，空间复杂度O(1)。

5. 矩阵幂方法

#include <stdio.h>

void multiply(int F[2][2], int M[2][2]) {
    int x = F[0][0]*M[0][0] + F[0][1]*M[1][0];
    int y = F[0][0]*M[0][1] + F[0][1]*M[1][1];
    int z = F[1][0]*M[0][0] + F[1][1]*M[1][0];
    int w = F[1][0]*M[0][1] + F[1][1]*M[1][1];
    
    F[0][0] = x;
    F[0][1] = y;
    F[1][0] = z;
    F[1][1] = w;
}

void power(int F[2][2], int n) {
    if (n <= 1) return;
    
    int M[2][2] = {{1,1},{1,0}};
    
    power(F, n/2);
    multiply(F, F);
    
    if (n%2 != 0) {
        multiply(F, M);
    }
}

int fibonacci_matrix(int n) {
    if (n <= 1) {
        return n;
    }
    
    int F[2][2] = {{1,1},{1,0}};
    power(F, n-1);
    return F[0][0];
}

int main() {
    int n = 10;
    printf("Fibonacci(%d) = %d\n", n, fibonacci_matrix(n));
    return 0;
}

特点：时间复杂度O(log n)，基于矩阵幂运算，适合大数计算。

6. 公式法（Binet公式）

#include <stdio.h>
#include <math.h>

int fibonacci_formula(int n) {
    double phi = (1 + sqrt(5)) / 2;
    return round(pow(phi, n) / sqrt(5));
}

int main() {
    int n = 10;
    printf("Fibonacci(%d) = %d\n", n, fibonacci_formula(n));
    return 0;
}

特点：时间复杂度O(1)，但由于浮点数精度问题，仅适用于较小的n。

总结

• 对于小规模n：递归方法最简单

• 对于中等规模n：迭代或动态规划方法最佳

• 对于大规模n：矩阵幂方法效率最高

• 公式法虽然时间复杂度最优，但受限于浮点数精度

实际应用中，迭代方法通常是首选，因为它简单、高效且不会出现递归的栈溢出问题。