c语言用递归法求斐波那契数列

以下是使用递归法求解斐波那契数列的C语言代码：

#include <stdio.h>

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

int main() {
    int n;
    printf("请输入要求第几个斐波那契数：");
    scanf("%d", &n);
    printf("第%d个斐波那契数为%d\n", n, fib(n));
    return 0;
}

相关问题

c语言设计四种求斐波那契数列

在C语言中，有多种方法可以用来求解斐波那契数列。下面是四种常见的方法：

方法一：递归法
使用递归法可以简洁地实现斐波那契数列的求解。递归法通过将问题分解为更小的子问题来求解。在代码中，我们定义一个递归函数，该函数接受一个整数n作为参数，返回斐波那契数列的第n项的值。具体实现代码如下：

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

引用

方法二：迭代法
迭代法是另一种常见的求解斐波那契数列的方法。它通过使用循环来逐步计算斐波那契数列的每一项。具体实现代码如下：

unsigned long fibonacci_iterative(unsigned long n) {
    unsigned long prev = 0;
    unsigned long current = 1;
    unsigned long next;
    
    if (n == 0) {
        return prev;
    }
    
    for (unsigned long i = 2; i <= n; i++) {
        next = prev + current;
        prev = current;
        current = next;
    }
    
    return current;
}

引用

方法三：矩阵法
矩阵法是一种高效的求解斐波那契数列的方法。它通过将斐波那契数列的计算转化为矩阵的乘法来实现。具体实现代码如下：

void matrix_multiply(unsigned long a = a + a = a + a = a + a = a + a = temp = temp = temp = temp = {{1, 1}, {1, 0}};
    unsigned long result = {{1, 0}, {0, 1}};
    
    while (n > 0) {
        if (n % 2 == 1) {
            matrix_multiply(result, matrix);
        }
        matrix_multiply(matrix, matrix);
        n /= 2;
    }
    
    return result = 0;
    fib = 1;
    
    for (unsigned long i = 2; i <= n; i++) {
        fib[i = fib[i-1 + fib[i-2];
    }
    
    return fib[n];
}

引用

综上所述，我们介绍了C语言中四种常见的求解斐波那契数列的方法：递归法、迭代法、矩阵法和动态规划法。每种方法都有其优点和适用场景，具体选择哪种方法取决于实际需求和性能要求。希望这些方法能够帮助到你。

用c语言设计四种求斐波那契数列的算法并测量运算时间

在C语言中，我们可以设计多种求解斐波那契数列的算法，这里我会介绍四种常见的方法：

1. **递归**:

#include <stdio.h>
#include <time.h>

// 递归函数
long long fibonacci_recursive(int n) {
    if (n <= 1)
        return n;
    else
        return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2);
}

int main() {
    clock_t start, end;
    int n = 40; // 测试数位防止无限递归
    start = clock();
    printf("%lld\n", fibonacci_recursive(n));
    end = clock();
    double time_spent = ((double)(end - start)) / CLOCKS_PER_SEC;
    printf("Time taken for recursive method: %.6f seconds\n", time_spent);
    return 0;
}

注意递归效率较低，因为它会重复计算很多已知的值。

2. **动态规划**:

#include <stdio.h>
#include <time.h>

// 动态规划版本
long long fibonacci_dp(int n) {
    long long fib[n+1];
    fib[0] = 0;
    fib[1] = 1;
    for (int i = 2; i <= n; i++) {
        fib[i] = fib[i-1] + fib[i-2];
    }
    return fib[n];
}

int main() {
    //...
    double time_spent;
    //...
}

这种方法存储了之前的结果，避免了重复计算。

3. **迭代**:

#include <stdio.h>
#include <time.h>

// 迭代法
long long fibonacci_iterative(int n) {
    long long fib = 0, prev = 1, curr = 1;
    if (n <= 1)
        return n;
    for (int i = 2; i <= n; i++) {
        fib = prev + curr;
        prev = curr;
        curr = fib;
    }
    return fib;
}

int main() {
    //...
    double time_spent;
    //...
}

迭代方式更高效，因为它只需要循环到所需位置。

4. **矩阵快速幂**:
这是一种利用矩阵乘法和指数运算提高速度的高级技巧，适合大数值场景，但对于小规模的斐波那契数，可能过于复杂。