Herr Deng桑的教學blog: 費式數列

2009年10月1日星期四

費式數列

費式數列:

f[0]=f[1]=1
f[n]=f[n-1]+f[n-2]

請用迴圈算到n最大還是正確的f[n]值!

為什麼不要用遞迴做?

64 則留言:

b9733192 提到...: #include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{

int f[50] ;
int i = 2 ;
f[0] = f[1] = 1 ;
while ( i <= 49 ) {
f[i] = f[i-1] + f[i-2] ;
i++ ;
}

cout << i << "->" << f[i] << endl ;

system("PAUSE");
return EXIT_SUCCESS;

}; 2009年10月1日下午3:01
B9733149 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[52];
    f[0]=f[1]=1;
    for (int i=2;i<=49;i++)
    {
        f[i]=f[i-1]+f[i-2];
        cout<<i<<"->"<<f[i]<<endl;
    }
    system ("pause");
    return 0;
}

因為會讓程式在求每一個費氏數時，都會發生重覆計算的現象; 2009年10月1日下午3:09
B9733138 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[52];
    f[0]=f[1]=1;
    for (int i=2;i<=49;i++)
    {
        f[i]=f[i-1]+f[i-2];
        cout<<i<<"->"<<f[i]<<endl;
    }
    system ("pause");
    return 0;
}

在求每個費式時會產生重複運算; 2009年10月1日下午3:10
b9733135 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[52];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
         f[i]=f[i-1]+f[i-2];
         cout<<i<<"->"<<f[i]<<endl;
    }
    system("pause");
    return 0;
}

因為會重複運算，時間會延長。; 2009年10月1日下午3:11
B9733171 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[52];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
         f[i]=f[i-1]+f[i-2];
         cout<<i<<"->"<<f[i]<<endl;
    }
    system("pause");
    return 0;
}

因為會重複運算，時間會延長。; 2009年10月1日下午3:12
B9733176 提到...: #include <iostream>
#include <cstdlib>
using namespace std;
int main()
{
    int f[52],n;
    f[0]=f[1]=1;
    for(n=2;n<=49;n++)
    {
    f[n]=f[n-1]+f[n-2];
    cout<<n<<"->"<<f[n]<<endl;
    }
    system("pause");
    return 0;
}

到45以前是準的

為何不用遞迴:
雖然遞迴函數可以很快地幫我們解決問題，但是它並不是一個有效率的寫法，因為我們在 F(n) 中呼叫了 F(n-1) 及 F(n-2)，而 F(n-1) 又會呼叫 F(n-2) 及 F(n-3)，如此一來，F(n-2) 就被重複呼叫了，隨著 n 越來越大，這個重複呼叫的次數會越來越大。; 2009年10月1日下午3:13
B9733165 提到...: #include <iostream>
using namespace std;
int main()
{
    int f[52];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
{
    f[i]=f[i-1]+f[i-2];
    cout<<i<<"->"<<f[i]<<endl;
}
    system("Pause");
    return 0;
}

到45以前是準的

Q:為什麼不用遞廻?
A:
雖然遞迴函數可以很快地幫我們解決問題，但是它並不是一個有效率的寫法，因為我們在 F(n) 中呼叫了 F(n-1) 及 F(n-2)，而 F(n-1) 又會呼叫 F(n-2) 及 F(n-3)，如此一來，F(n-2) 就被重複呼叫了，隨著 n 越來越大，這個重複呼叫的次數會越來越大。; 2009年10月1日下午3:13
B9733184 提到...: #include <stdio.h>
#include <stdlib.h>
int main()
{
    int f[50];
    f[0]=1;
    f[1]=1;
    int i;
    for(i=2;i<=49;i++)
    {
         f[i]=f[i-1]+f[i-2];
         printf("f[%d]=%d\n",i,f[i]);
         }
         system("pause");
         return 0;
         }

到45以前是準的

如果你的遞迴程式的主迴圈當中，最多只有一個分枝會產生遞迴呼叫，那麼這其實是一個 linear recursive function，其實根本就不需要遞迴。例如二分搜尋法，二元樹的搜尋，或前述的的階乘都是，其實只需要一個迴圈垂直地做 n 次就可以了。這種情況用遞迴，似乎有點小題大作; 2009年10月1日下午3:14
B9733141 提到...: #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int i;
unsigned f[50];
printf("輸入i:\n");
scanf("%d",&i);
f[0]=1;
f[1]=1;
     for(i=2;i<=49;i++)
     {
      f[i]=f[i-1]+f[i-2];
      printf("%d\n",i);
      printf("%d\n",f[i]);
     }

system("PAUSE");
return 0;
}
最大到45最大f[45]=1836311903
因為當呼叫到f(n-1)時,會重複做f(n-1)!!!; 2009年10月1日下午3:15
B9733148 提到...: #include <stdio.h>
#include <stdlib.h>
int main()
{
    int f[50];
    f[0]=1;
    f[1]=1;
    int i;
    for(i=2;i<=49;i++)
    {
         f[i]=f[i-1]+f[i-2];
         printf("f[%d]=%d\n",i,f[i]);
         }
         system("pause");
         return 0;
         }

到45是準的

如果你的遞迴程式的主迴圈當中，最多只有一個分枝會產生遞迴呼叫，那麼這其實是一個 linear recursive function，其實根本就不需要遞迴。例如二分搜尋法，二元樹的搜尋，或前述的的階乘都是，其實只需要一個迴圈垂直地做 n 次就可以了。這種情況用遞迴，似乎有點小題大作; 2009年10月1日下午3:17
b9733166 提到...: #include <stdio.h>
#include <stdlib.h>
int main()
{
    int i,f[50];
    printf("輸入;");
    scanf("%d",&i);
    f[0]=f[1]=1;
      for(i=2;i<=49;i++)
      {
        f[i]=f[i-1]+f[i-2];
        printf("%d\n",i);
        printf("%d\n",f[i]);
      }
    system ("pause");
    return 0;
}

N為45
為何不用遞迴是因為會重複作n-1
但是答應仍相同; 2009年10月1日下午3:17
B9733173 提到...: f[46]開始出現錯誤

不使用遞迴是因為當n的數值太大，電腦會作很多次多餘的遞迴運算，程式效率低; 2009年10月1日下午3:18
b9733168 提到...: 從46開始出現錯誤

不使用遞迴，因為當n大一點，電腦會作很多次多餘的遞迴運算，程式效率低; 2009年10月1日下午3:20
B9733124 提到...: #include <stdio.h>
#include <stdlib.h>
int main ()
{
    int f[52];
    f[0]=1;
    f[1]=1;
    for(int i=2;i<=49;i++)
    {
           f[i]=f[i-1]+f[i-2];
           printf("f[%d]=%d\n",i,f[i]);
           }
    system("pause");
    return 0;
    }

為神不用遞迴,因為重複運算,時間就會變長,導致作業時間家長; 2009年10月1日下午3:24
B9733175 提到...: #include <stdio.h>
#include <stdlib.h>
int main ()
{
    int f[52];
    f[0]=1;
    f[1]=1;
    for(int i=2;i<=49;i++)
    {
           f[i]=f[i-1]+f[i-2];
           printf("f[%d]=%d\n",i,f[i]);
           }
    system("pause");
    return 0;
    }

為神不用遞迴,因為重複運算,時間就會變長,; 2009年10月1日下午3:25
B9733151 提到...: #include <stdio.h>
#include <stdlib.h>
int main ()
{
    int f[52];
    f[0]=1;
    f[1]=1;
    for(int i=2;i<=49;i++)
    {
           f[i]=f[i-1]+f[i-2];
           printf("f[%d]=%d\n",i,f[i]);
           }
    system("pause");
    return 0;
    }

為神不用遞迴,因為重複運算,時間就會變長,; 2009年10月1日下午3:25
B9733150 提到...: #include <stdio.h>
#include <stdlib.h>
int main ()
{
    int f[52];
    f[0]=1;
    f[1]=1;
    for(int i=2;i<=49;i++)
    {
           f[i]=f[i-1]+f[i-2];
           printf("f[%d]=%d\n",i,f[i]);
           }
    system("pause");
    return 0;
    }

為神不用遞迴,因為重複運算,時間就會變長,; 2009年10月1日下午3:25
B9733137 提到...: include <iostream>
using namespace std;
int main()
{
unsigned f[52];
int i;
f[0]=f[1]=1;
for(i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
cout<<i<<"->"<<f[i]<<endl;
}
system("pause");
return 0;
}

可以參考到46

因為用遞回會延長時間成為指數時間; 2009年10月1日下午3:28
B9733192 提到...: #include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{

unsigned f[50] ;
int i = 2 ;
f[0] = f[1] = 1 ;
while ( i <= 49 ) {
f[i] = f[i-1] + f[i-2] ;
cout << i << "->" << f[i] << endl ;
i++ ;

}

system("PAUSE");
return EXIT_SUCCESS;

}

i跑到46的時候還是正確的值
當i=47時，會出現不正確的數值

因為時間複雜度會成為指數時間而沒辦法用; 2009年10月1日下午3:28
b9733127 提到...: #include <stdio.h>
#include <stdlib.h>
int main()
{
    int i,f[50];
    printf("輸入;");
    scanf("%d",&i);
    f[0]=f[1]=1;
      for(i=2;i<=49;i++)
      {
        f[i]=f[i-1]+f[i-2];
        printf("%d\n",i);
        printf("%d\n",f[i]);
      }
    system ("pause");
    return 0;
}

A:45; 2009年10月1日下午3:29
B9733134 提到...: #include <iostream>
#include <cstdlib>
using namespace std;
int main()
{
    unsigned f[50];
    f[0]=f[1]=1;
    for(int i=2;i<=49;i++)
    {
        f[i]=f[i-1]+f[i-2];
        cout<<"f["<<i<<"]="<<f[i]<<'\n';
    }
    system("pause");
    return 0;
}

用遞迴時間複雜度大; 2009年10月1日下午3:29
B9733161 提到...: 46開始
當 n 大一點，電腦會作很多次多餘的遞迴運算，程式效率低; 2009年10月1日下午3:30
b9733123 提到...: #include <stdio.h>
#include <stdlib.h>
int main()
{
int f[50];
f[0]=1;
f[1]=1;
int i;
for(i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
printf("f(%d)-->",i);
printf("-->%d\n",f[i]);
}
system("pause");
return 0;
}

如果你的遞迴程式的主迴圈當中，最多只有一個分枝會產生遞迴呼叫，那麼這其實是一個 linear recursive function，其實根本就不需要遞迴。例如二分搜尋法，二元樹的搜尋，或前述的的階乘都是，其實只需要一個迴圈垂直地做 n 次就可以了。這種情況用遞迴，似乎有點小題大作，只是因為它用不用遞迴都可以解，而且比較簡單，所以教科書常拿它來做例子。; 2009年10月1日下午3:30
B9733163 提到...: 46開始
當 n 大一點，電腦會作很多次多餘的遞迴運算，程式效率低; 2009年10月1日下午3:31
b9733131 提到...: #include<iostream>
#include<cstdlib>
using namespace std;
int main(){
unsigned f[50];
f[0]=f[1]=1;
int i;
for(i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
cout<<"f["<<i<<"]="<<f[i]<<'\n';
}
system("pause");
return 0;
}

遞迴方式的執行時間比迴圈方式久; 2009年10月1日下午3:31
B9733133 提到...: include <iostream>
using namespace std;
int main()
{
unsigned f[52];
int i;
f[0]=f[1]=1;
for(i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
cout<<i<<"->"<<f[i]<<endl;
}
system("pause");
return 0;
}

可以參考到46

使用遞回會延長時間; 2009年10月1日下午3:31
b9733188 提到...: #include <stdio.h>
#include <stdlib.h>
int main()
{
    int i,f[50];
    printf("輸入;");
    scanf("%d",&i);
    f[0]=f[1]=1;
      for(i=2;i<=49;i++)
      {
        f[i]=f[i-1]+f[i-2];
        printf("%d\n",i);
        printf("%d\n",f[i]);
      }
    system ("pause");
    return 0;
}

a:45

因為會呼叫很多次來所以不需用遞迴!; 2009年10月1日下午3:31
b9733127 提到...: #include <stdio.h>
#include <stdlib.h>
int main()
{
    int i,f[50];
    printf("輸入;");
    scanf("%d",&i);
    f[0]=f[1]=1;
      for(i=2;i<=49;i++)
      {
        f[i]=f[i-1]+f[i-2];
        printf("%d\n",i);
        printf("%d\n",f[i]);
      }
    system ("pause");
    return 0;
}

A:45

因為會一直呼叫,所以無需用遞迴; 2009年10月1日下午3:32
b9733140 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[50];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<49;i++)
    {
        f[i]=f[i-1]+f[i-2];
        cout<<i<<"->"<<f[i]<<endl;
    }

    system("pause");
    return 0;
}

為什麼不用遞迴?
用遞迴函數程式呼叫多次,比較費時
用for迴圈不用呼叫程式; 2009年10月1日下午3:32
B9733194 提到...: include <iostream>
using namespace std;
int main()
{
unsigned f[52];
int i;
f[0]=f[1]=1;
for(i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
cout<<i<<"->"<<f[i]<<endl;
}
system("pause");
return 0;
}

可以參考到46

使用遞回會延長時間; 2009年10月1日下午3:32
b9733174 提到...: #include <stdio.h>
#include <stdlib.h>
int main()
{
int f[50];
f[0]=1;
f[1]=1;
int i;
for(i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
printf("f(%d)-->",i);
printf("-->%d\n",f[i]);
}
system("pause");
return 0;
}

如果你的遞迴程式的主迴圈當中，最多只有一個分枝會產生遞迴呼叫，那麼這其實是一個 linear recursive function，其實根本就不需要遞迴。例如二分搜尋法，二元樹的搜尋，或前述的的階乘都是，其實只需要一個迴圈垂直地做 n 次就可以了。這種情況用遞迴，似乎有點小題大作，只是因為它用不用遞迴都可以解，而且比較簡單，所以教科書常拿它來做例子。; 2009年10月1日下午3:32
b9733181 提到...: #include <stdio.h>
#include <stdlib.h>
int main()
{
int f[50];
f[0]=1;
f[1]=1;
int i;
for(i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
printf("f(%d)-->",i);
printf("-->%d\n",f[i]);
}
system("pause");
return 0;
}

如果你的遞迴程式的主迴圈當中，最多只有一個分枝會產生遞迴呼叫，那麼這其實是一個 linear recursive function，其實根本就不需要遞迴。例如二分搜尋法，二元樹的搜尋，或前述的的階乘都是，其實只需要一個迴圈垂直地做 n 次就可以了。這種情況用遞迴，似乎有點小題大作，只是因為它用不用遞迴都可以解，而且比較簡單，所以教科書常拿它來做例子。; 2009年10月1日下午3:33
B9733130 提到...: 1.
#include <iostream>
using namespace std;
int main(){
    unsigned f[50];
    f[0]=f[1]=1;
    for(int i=2;i<50;i++){
        f[i]=f[i-1]+f[i-2];
        cout<<i<<"->"<<f[i]<<endl;
    }
    system("pause");
    return 0;
}

到46準的
2.雖然遞迴函數可以很快地幫我們解決問題，但是它並不是一個有效率的寫法，因為我們在 F(n) 中呼叫了 F(n-1) 及 F(n-2)，而 F(n-1) 又會呼叫 F(n-2) 及 F(n-3)，如此一來，F(n-2) 就被重複呼叫了，隨著 n 越來越大，這個重複呼叫的次數會越來越大; 2009年10月1日下午3:34
B9733129 提到...: 1.
#include <iostream>
using namespace std;
int main(){
    unsigned f[50];
    f[0]=f[1]=1;
    for(int i=2;i<50;i++){
        f[i]=f[i-1]+f[i-2];
        cout<<i<<"->"<<f[i]<<endl;
    }
    system("pause");
    return 0;
}

到46準的
2.雖然遞迴函數可以很快地幫我們解決問題，但是它並不是一個有效率的寫法，因為我們在 F(n) 中呼叫了 F(n-1) 及 F(n-2)，而 F(n-1) 又會呼叫 F(n-2) 及 F(n-3)，如此一來，F(n-2) 就被重複呼叫了，隨著 n 越來越大，這個重複呼叫的次數會越來越大; 2009年10月1日下午3:34
b9733193 提到...: #include <cstdlib>
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
    int f[50];
    f[0]=f[1]=1;
    for(int i=2;i<=49;i++)
{
    f[i]=f[i-1]+f[i-2];
    cout<<i<<"->"<<f[i]<<endl;
}
    system("PAUSE");
    return EXIT_SUCCESS;
}
因為計算出來的是指數時間。; 2009年10月1日下午3:34
B9733146 提到...: #include <stdio.h>
#include <stdlib.h>
int main()
{
    int f[50];
    f[0]=1;
    f[1]=1;
    int i;
    for(i=2;i<=49;i++)
    {
         f[i]=f[i-1]+f[i-2];
         printf("f[%d]=%d\n",i,f[i]);
         }
         system("pause");
         return 0;
         }

如果你的遞迴程式的主迴圈當中，最多只有一個分枝會產生遞迴呼叫，那麼這其實是一個 linear recursive function，其實根本就不需要遞迴。例如二分搜尋法，二元樹的搜尋，或前述的的階乘都是，其實只需要一個迴圈垂直地做 n 次就可以了。這種情況用遞迴，似乎有點小題大作; 2009年10月1日下午3:35
B9733145 提到...: 1.
#include <iostream>
using namespace std;
int main(){
    unsigned f[50];
    f[0]=f[1]=1;
    for(int i=2;i<50;i++){
        f[i]=f[i-1]+f[i-2];
        cout<<i<<"->"<<f[i]<<endl;
    }
    system("pause");
    return 0;
}

到46準的
2.雖然遞迴函數可以很快地幫我們解決問題，但是它並不是一個有效率的寫法，因為我們在 F(n) 中呼叫了 F(n-1) 及 F(n-2)，而 F(n-1) 又會呼叫 F(n-2) 及 F(n-3)，如此一來，F(n-2) 就被重複呼叫了，隨著 n 越來越大，這個重複呼叫的次數會越來越大; 2009年10月1日下午3:35
b9733143 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[50];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
                      f[i]=f[i-1]+f[i-2];
                      cout<<i<<"->"<<f[i]<<endl;
                      }
    system("pause");
    return 0;
}

因為使用遞迴，會呼叫比較多次，用For迴圈就不用呼叫; 2009年10月1日下午3:35
B9133144 提到...: 1.
#include <iostream>
using namespace std;
int main(){
    unsigned f[50];
    f[0]=f[1]=1;
    for(int i=2;i<50;i++){
        f[i]=f[i-1]+f[i-2];
        cout<<i<<"->"<<f[i]<<endl;
    }
    system("pause");
    return 0;
}

到46準的
2.雖然遞迴函數可以很快地幫我們解決問題，但是它並不是一個有效率的寫法，因為我們在 F(n) 中呼叫了 F(n-1) 及 F(n-2)，而 F(n-1) 又會呼叫 F(n-2) 及 F(n-3)，如此一來，F(n-2) 就被重複呼叫了，隨著 n 越來越大，這個重複呼叫的次數會越來越大; 2009年10月1日下午3:35
b9733132 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[50];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
                      f[i]=f[i-1]+f[i-2];
                      cout<<i<<"->"<<f[i]<<endl;
                      }
    system("pause");
    return 0;
}

因為使用遞迴，會呼叫比較多次，用For迴圈就不用呼叫; 2009年10月1日下午3:36
b9733147 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[50];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
                      f[i]=f[i-1]+f[i-2];
                      cout<<i<<"->"<<f[i]<<endl;
                      }
    system("pause");
    return 0;
}

因為使用遞迴，會呼叫比較多次，用For迴圈就不用呼叫; 2009年10月1日下午3:36
b9733159 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[50];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
                      f[i]=f[i-1]+f[i-2];
                      cout<<i<<"->"<<f[i]<<endl;
                      }
    system("pause");
    return 0;
}

因為使用遞迴，會呼叫比較多次，用For迴圈就不用呼叫; 2009年10月1日下午3:36
b9733128 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[50];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
                      f[i]=f[i-1]+f[i-2];
                      cout<<i<<"->"<<f[i]<<endl;
                      }
    system("pause");
    return 0;
}

因為使用遞迴，會呼叫比較多次，用For迴圈就不用呼叫; 2009年10月1日下午3:36
b9733142 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[50];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
                      f[i]=f[i-1]+f[i-2];
                      cout<<i<<"->"<<f[i]<<endl;
                      }
    system("pause");
    return 0;
}

因為使用遞迴，會呼叫比較多次，用For迴圈就不用呼叫; 2009年10月1日下午3:37
b9733178 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[50];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
                      f[i]=f[i-1]+f[i-2];
                      cout<<i<<"->"<<f[i]<<endl;
                      }
    system("pause");
    return 0;
}

因為使用遞迴，會呼叫比較多次，用For迴圈就不用呼叫; 2009年10月1日下午3:37
B9533009 提到...: #include <cstdlib>
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
    int* f=new int[50];
f[0]=f[1]=1;
for (int i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
cout<<i<<"="<<f[i]<<endl;
}
    system("PAUSE");
    return EXIT_SUCCESS;
}

因為可以減少不必要打這麼多的程式
還有減少運算時間
加速運算; 2009年10月1日下午3:37
B9533055 提到...: #include <cstdlib>
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
    int* f=new int[50];
    f[0]=f[1]=1;
    for(int i=2;i<=49;i++)
    {
    f[i]=f[i-1]+f[i-2];
    cout<<i<<"--"<<f[i]<<endl;
    }


    system("PAUSE");
    return EXIT_SUCCESS;
}

為何不要用遞迴做？
減少時間。（因為遞迴運作時間較長）; 2009年10月1日下午3:37
b9733183 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[50];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
                      f[i]=f[i-1]+f[i-2];
                      cout<<i<<"->"<<f[i]<<endl;
                      }
    system("pause");
    return 0;
}

因為使用遞迴，會呼叫比較多次，用For迴圈就不用呼叫; 2009年10月1日下午3:37
B9733141 提到...: (1)#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int i;
unsigned f[50];
printf("輸入i:\n");
scanf("%d",&i);
f[0]=1;
f[1]=1;
     for(i=2;i<=49;i++)
     {
      f[i]=f[i-1]+f[i-2];
      printf("%d\n",i);
      printf("%d\n",f[i]);
     }

system("PAUSE");
return 0;
}
最大45最大f[45]=1836311903
(2)因為會造成指數時間; 2009年10月1日下午3:37
b9733182 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[50];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
                      f[i]=f[i-1]+f[i-2];
                      cout<<i<<"->"<<f[i]<<endl;
                      }
    system("pause");
    return 0;
}

因為使用遞迴，會呼叫比較多次，用For迴圈就不用呼叫; 2009年10月1日下午3:38
b9733179 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[50];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
                      f[i]=f[i-1]+f[i-2];
                      cout<<i<<"->"<<f[i]<<endl;
                      }
    system("pause");
    return 0;
}

因為使用遞迴，會呼叫比較多次，用For迴圈就不用呼叫; 2009年10月1日下午3:38
b9733172 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[50];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
                      f[i]=f[i-1]+f[i-2];
                      cout<<i<<"->"<<f[i]<<endl;
                      }
    system("pause");
    return 0;
}

因為使用遞迴，會呼叫比較多次，用For迴圈就不用呼叫; 2009年10月1日下午3:38
b9733162 提到...: #include <iostream>
using namespace std;
int main()
{
    unsigned f[50];
    int i;
    f[0]=f[1]=1;
    for(i=2;i<=49;i++)
    {
                      f[i]=f[i-1]+f[i-2];
                      cout<<i<<"->"<<f[i]<<endl;
                      }
    system("pause");
    return 0;
}

因為使用遞迴，會呼叫比較多次，用For迴圈就不用呼叫; 2009年10月1日下午3:39
B9533067 提到...: #include <cstdlib>
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
    int f[50];
    f[0]=f[1]=1;
    for(int i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
cout<<i<<"去"<<f[i]<<endl;
}
    system("PAUSE");
    return EXIT_SUCCESS;
}

2.出來時間是指數時間; 2009年10月1日下午3:39
b9633029 提到...: #include<iostream>
#include<cstdlib>
using namespace std;
int main(){
          unsigned f[50];
          f[0]=f[1]=1;
          int i;
          for(i=2;i<=49;i++)
          {
            f[i]=f[i-1]+f[i-2];
            cout<<"f["<<i<<"]="<<f[i]<<'\n';
            }
          system("pause");
          return 0;
          }
假若輸入的數列為5
就會印出：迴圈方式執行結果：5, 執行時間：112微秒
遞迴方式執行結果：5, 執行時間：59微秒
遞迴方式的執行時間為迴圈方式的 0.53 倍。; 2009年10月1日下午3:39
b9733125 提到...: #include <iostream>
using namespace std;
int main(int argc,char*argv[])
{
unsigned f[50];
int i=2;
f[0]=f[1]=1;
while(i<=49)
{

f[i]=f[i-1]+f[i-2];
cout<<i<<"->"<<f[i]<<endl;
i++;
}
system("Pause");
return EXIT_SUCCESS;
}

因為i=45時，才是正確的數值
因為時間複雜度會為指數時間。; 2009年10月1日下午3:41
B9733170 提到...: #include <stdio.h>
#include <stdlib.h>
int main()
{
unsigned f[50];
int i;
f[0]=f[1]=1;
for(i=2;i<=49;i++)
{
   f[i]=f[i-1]+f[i-2];
}
for(i=0;i<=49;i++)
   {
   printf("%d\n",i);
   printf("%d\n",f[i]);
   }
system("pause");
return 0;
}

因為i=45時，才是正確的數值
因為時間複雜度為指數時間。; 2009年10月1日下午3:41
b9733126 提到...: #include<stdio.h>
#include<stdlib.h>
int main()
{
int f[50];
f[0]=f[1]=1;
for(int i=2;i<50;i++){
f[i]=f[i-1]+f[i-2];
printf("%d\n",i);
printf("%d\n" ,f[i]);
}
system("pause");
return 0;
}

因為指數時間; 2009年10月1日下午3:45
b9533041 提到...: #include <iostream>
using namespace std;
int main()
{
unsigned f[50];
int i;
f[0]=f[1]=1;
for(i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
cout<<i<<"->"<<f[i]<<endl;
}
system("pause");
return 0;
}

使用遞迴，呼叫次數會比較多，使用For迴圈不用呼叫; 2009年10月14日晚上11:34
b9533031 提到...: #include <iostream>
using namespace std;
int main()
{
unsigned f[52];
f[0]=f[1]=1;
for (int i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
cout<<i<<"->"<<f[i]<<endl;
}
system ("pause");
return 0;
}; 2009年10月14日晚上11:36
b9533031 提到...: #include <iostream>
using namespace std;
int main()
{
unsigned f[52];
f[0]=f[1]=1;
for (int i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
cout<<i<<"->"<<f[i]<<endl;
}
system ("pause");
return 0;
}; 2009年10月14日晚上11:38
B9533053 提到...: unsigned f[50];
int i;
f[0]=f[1]=1;
for(i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
}
for(i=0;i<=49;i++)
{
printf("%d\n",i);
printf("%d\n",f[i]);
}
system("pause");
return 0;
}

因為i=45時，才是正確的數值
因為時間複雜度為指數時間。; 2009年10月14日晚上11:42
B9533145 提到...: #include <iostream>

using namespace std;

int main()
{
unsigned f[52];
int i;
f[0]=f[1]=1;
for(i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
cout<<i<<"->"<<f[i]<<endl;
}
system("pause");
return 0;
}

參考至46 使用遞回會延長時間; 2009年10月26日晚上10:24
b9633006 提到...: #include <stdio.h>
#include <stdlib.h>
int main ()
{
int f[52];
f[0]=1;
f[1]=1;
for(int i=2;i<=49;i++)
{
f[i]=f[i-1]+f[i-2];
printf("f[%d]=%d\n",i,f[i]);
}
system("pause");
return 0;
}

為神不用遞迴,因為重複運算,時間就會變長,; 2009年10月28日晚上8:12

張貼留言

訂閱：張貼留言 (Atom)

Herr Deng桑的教學blog

網頁

herrDeng網內搜尋

Ads

2009年10月1日星期四

費式數列

64 則留言:

熱門文章

DengSir7 Google Display

programming

網頁

herrDeng網內搜尋

Ads

2009年10月1日 星期四

費式數列

64 則留言:

熱門文章

DengSir7 Google Display

programming

2009年10月1日星期四