Question

到目前为止我有这个代码。它的工作原理和我想做的事情。我想知道我能不能做得更好。我并不真正关心用户输入或任何其他＆＃34;完成触摸，＆＃34;只是想让代码更高效，也许对未来的项目更有用。过多的评论仅供我个人使用，当我回到旧项目以供参考时，我发现它更容易阅读。谢谢！

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

void fabonacci(int * fibArr,int numberOfSeries){
    int n;

    //allocate memory size
    fibArr = malloc (sizeof(int) * numberOfSeries);
    //first val, fib = 0
    *fibArr = 0;//100
    fibArr++;
    //second val, fib = 1
    *fibArr = 1;//104
    fibArr++;

    //printing first two fib values 0 and 1
    printf("%i\n%i\n", *(fibArr- 2),*(fibArr- 1));

    //loop for fib arr
    for(n=0;n<numberOfSeries -2;n++,fibArr++){
        //108 looking back at 104 looking back at 100
        //112 looking back at 108 looking back at 104
        *fibArr = *(fibArr-1) + *(fibArr -2);
        //printing fib arr
        printf("%i\n", *fibArr);
    }
}

int main(){
    //can implm user input if want
    int n = 10;
    int *fib;

    //calling 
    fabonacci(fib,n);
}

Answer 1

你的代码介于两种可能的解释之间，我无法分辨你的意思。如果您希望fibonacci(n)只提供n号码并且没有任何外部副作用，您应该按如下方式编写：

int fibonacci(int n) {
   int lo, hi;
   lo = 0;
   hi = 1;
   while(n-- > 0) {
     int tmp = hi;
     lo = hi;
     hi = lo + tmp;
   }
   return lo;
}

您不需要malloc或free，因为这需要持续的堆栈分配空间。

如果你想在计算时将整个序列存储在内存中，你可能还需要分配内存，因为这样可以让调用者控制数字的去向。

// n < 0 => undefined behavior
// not enough space allocated for (n + 1) ints in res => undefined behavior
void fibonacci(int *res, int n) {
  res[0] = 0;
  if(n == 0) { return; }
  res[1] = 1;
  if(n == 1) { return; }
  for(int i = 2; i <= n; i++) {
    res[i] = res[i-1] + res[i-2];
  }
}

现在调用者的工作是分配内存：

int main(){
  int fib[10]; // room for F_0 to F_9
  fibonacci(fib, 9); // fill up to F_9

  int n = ...; // some unknown number
  int *fib2 = malloc(sizeof(int) * (n + 2)); // room for (n + 2) values
  if(fib2 == NULL) { /* error handling */ }
  fibonacci(fib2 + 1, n); // leave 1 space at the start for other purposes.
  // e.g. you may want to store the length into the first element
  fib2[0] = n + 1;
  // this fibonacci is more flexible than before
  // remember to free it
  free(fib2);
}

你可以将它包装起来以分配空间本身，同时仍然保留更灵活的版本：

int *fibonacci_alloc(int n) {
    int *fib = malloc(sizeof(int) * (n + 1));
    if(fib == NULL) { return NULL; }
    fibonacci(fib, n);
    return fib;
}

Answer 2

改进代码的一种方法是让调用者创建数组，并将数组传递给fibonacci函数。这消除了fibonacci分配内存的需要。请注意，如果需要，调用者可以分配/释放，或者调用者只能声明一个数组。

另一个改进是在fibonacci函数内使用数组表示法。您可能认为指针解决方案具有更好的性能。这没关系。在溢出32位n之前，int的最大值为47，因此n不足以将性能作为考虑因素。

最后，fibonacci函数应该保护自己免受n的错误值的影响。例如，如果n为1，则函数应在第一个数组条目中放置0，而不是触及任何其他条目。

#include <stdio.h>

void fibonacci(int *array, int length)
{
    if (length > 0)
        array[0] = 0;
    if (length > 1)
        array[1] = 1;

    for (int i = 2; i < length; i++)
        array[i] = array[i-1] + array[i-2];
}

int main(void)
{
    int fib[47];
    int n = sizeof(fib) / sizeof(fib[0]);

    fibonacci(fib, n);

    for (int i = 0; i < n; i++)
        printf("fib[%d] = %d\n", i, fib[i]);
}

Nth Fibonacci在C中使用指针;递归和数组

2 个答案: