Herr Deng桑的教學blog: Ex8. 費氏數列Visual C#遞迴函式實作 Fibonacci sequence

2020年4月28日星期二

Ex8. 費氏數列Visual C#遞迴函式實作 Fibonacci sequence

1. 何謂遞迴函數？
2. 實作費氏數列，用遞迴方法

87 則留言:

b10833042謝孟修提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1) return n;
else return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("f({0}={1}", n, f(n));
Console.Read();
}
}
}; 2020年4月29日上午9:34
b10833069 鍾秉哲提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);

}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for(int n=0; n<=40; n++)
Console.WriteLine("ff({0})={1}",n,ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:34
b10833148張詔明提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1) return n;
else return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("f({0}={1}", n, f(n));
Console.Read();
}
}
}; 2020年4月29日上午9:34
b10833023 陳姿茹提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _0429
{
class Program
{
static int ff(int n)
{
if (n==0||n==1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:35
B10833043 彭律惠提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{
if(n==0||n==1) return n;
else return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}",n,ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:35
A10833002 提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace F
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
for (int n = 0; n <= 40; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:35
b10833033 蔡孟頻提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{
if (n ==0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={0};", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:36
B10833082 黃鈺淇提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _2020._04._29
{
class Program
{
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _2020._04._29
{
class Program
{
static int ff(int n)
{
if(n==0||n==1)
return n;
else
return ff(n-1) + ff(n-2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for(int n=0; n<=40; n++)
Console.WriteLine("ff({0})={1}" , n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:36
b10833027呂沂真提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for(int n=0;n<=50;n++)
Console.WriteLine("ff({0})={1}",n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:37
b10833042謝孟修提到...: 之所以能夠透過遞回函式，是因為函式堆疊（stack）在執行時有一個特性，當某個函式呼叫另一個函式時，需要等到裡面的函式執行完產生結果後，才會繼續回來執行自己的函式內容，而這樣的情況也被稱作後進先出（Last in First Out, LIFO）
也就是說，當我們在 first() 裡呼叫 last() 時，需要等 last() 執行完後，才會回到 first() 繼續執行。
另外，在寫遞回函式的時候一定記得設定終止條件，否則很容易跳不出來，導致無窮迴圈的情況產生。; 2020年4月29日上午9:38
b10833148張詔明提到...: 之所以能夠透過遞回函式，是因為函式堆疊（stack）在執行時有一個特性，當某個函式呼叫另一個函式時，需要等到裡面的函式執行完產生結果後，才會繼續回來執行自己的函式內容，而這樣的情況也被稱作後進先出（Last in First Out, LIFO）
也就是說，當我們在 first() 裡呼叫 last() 時，需要等 last() 執行完後，才會回到 first() 繼續執行。
另外，在寫遞回函式的時候一定記得設定終止條件，否則很容易跳不出來，導致無窮迴圈的情況產生。; 2020年4月29日上午9:38
B10833029 余柏翰提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1) return n;
else return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("費式數列");
for (int n = 0; n <= 40; n++)
Console.WriteLine("f({0})={1}", n, f(n));
Console.Read();
}
}
}; 2020年4月29日上午9:38
A10833002 提到...: 1.
我們在函數 F(n) 中又呼叫函數 F(n-1) 及 F(n-2)，像這樣在函數中又呼叫自己的寫法，就叫做「遞迴 Recursion」，而這種函數就稱為「遞迴函數 Recursive Function」。遞迴函數一開頭要先設定結束條件，否則會無窮循環下去，而遞迴呼叫自己的時候，必須改變它的參數，例如：

int R(int n)

{

if(結束條件成立) return 預設值;

return R( n 的運算式 );

}

2.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace F
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
for (int n = 0; n <= 40; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:38
B10833029 余柏翰提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1) return n;
else return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("費式數列");
for (int n = 0; n <= 40; n++)
Console.WriteLine("f({0})={1}", n, f(n));
Console.Read();
}
}
}; 2020年4月29日上午9:38
B10833043 彭律惠提到...: 遞迴（英語：Recursion），又譯為遞歸，在數學與電腦科學中，是指在函數的定義中使用函數自身的方法。遞迴一詞還較常用於描述以自相似方法重複事物的過程。例如，當兩面鏡子相互之間近似平行時，鏡中巢狀的圖像是以無限遞迴的形式出現的。也可以理解為自我複製的過程。; 2020年4月29日上午9:39
b10833002田昌弘提到...: 函數 F(n) 中又呼叫函數 F(n-1) 及 F(n-2)，像這樣在函數中又呼叫自己的寫法，就叫做「遞迴 Recursion」，而這種函數就稱為「遞迴函數 Recursive Function」。遞迴函數一開頭要先設定結束條件，否則會無窮循環下去，而遞迴呼叫自己的時候，必須改變它的參數，例如：

int R(int n)

{

if(結束條件成立) return 預設值;

return R( n 的運算式 );

}

-------------------------------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _123
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1)
return n;
else
return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("費氏數列");
for (int n = 0; n <= 40; n++)
Console.WriteLine("f({0})={1}", n, f(n));
Console.Read();
}
}
}; 2020年4月29日上午9:39
B10833047馮群赫提到...: 說明：費式數列的前兩項為 1、1，之後的每一項為前兩項之和，即 Fn=Fn-1+Fn-2，費式數列的前 10 項為：1、1、2、3、5、8、13、21、34、55。由使用者輸入一個正數數 n ( n < 40 )，計算出費式數列的第 n 項之值並輸出之。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);

}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:39
B10833050 張少豪提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 40; n++)
Console.WriteLine("ff({0})={1}",n,ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:40
b10833024 王翔緯提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for(int n=0;n<=50; n++)
Console .WriteLine ("ff({0})={1}",n,ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:40
b10833021 提到...: 剛才我們在函數 F(n) 中又呼叫函數 F(n-1) 及 F(n-2)，像這樣在函數中又呼叫自己的寫法，就叫做「遞迴 Recursion」，而這種函數就稱為「遞迴函數 Recursive Function」。遞迴函數一開頭要先設定結束條件，否則會無窮循環下去，而遞迴呼叫自己的時候，必須改變它的參數，例如：

int R(int n)

{

if(結束條件成立) return 預設值;

return R( n 的運算式 );

}
_______________________________________________________________

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 費式係數
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個計算費式數列的程式");
for (int n = 0; n <= 40; n++)
Console.WriteLine("ff({0})={1}",n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:41
B10833082 黃鈺淇提到...: 1.何謂遞迴函數?
A:在數學和電腦科學中，遞迴指由一種（或多種）簡單的基本情況定義的一類物件或方法，並規定其他所有情況都能被還原為其基本情況。; 2020年4月29日上午9:41
B10833026鄭亞易提到...: 1.
遞迴函數就是在函數的定義裏面呼叫自己的函數。遞迴函數至少需要包含終止條件與遞迴條件兩個部份。遞迴可以讓程式與數學定義相契合,程式碼較為簡潔易懂。遞迴可能會重複計算相同的東西多次,造成效能的浪費。
2.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 40; n++)
Console.WriteLine("ff({0})={1})", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:42
b10833024 王翔緯提到...: 遞回函式（recursive function）簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算（factorial）。
階層聽起來可能很陌生，但是大家高中數學一定接觸過，例如 5! = 5 x 4 x 3 x 2 x 1。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for(int n=0;n<=50; n++)
Console .WriteLine ("ff({0})={1}",n,ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:44
B10833050 張少豪提到...: 遞回函式（recursive function）簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算（factorial）。
階層聽起來可能很陌生，但是大家高中數學一定接觸過，例如 5! = 5 x 4 x 3 x 2 x 1。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 40; n++)
Console.WriteLine("ff({0})={1}",n,ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:45
A10833001林承君提到...: 遞迴函數說明
剛才我們在函數 F(n) 中又呼叫函數 F(n-1) 及 F(n-2)，像這樣在函數中又呼叫自己的寫法，就叫做「遞迴 Recursion」，而這種函數就稱為「遞迴函數 Recursive Function」。遞迴函數一開頭要先設定結束條件，否則會無窮循環下去，而遞迴呼叫自己的時候，必須改變它的參數，例如：

int R(int n)

{

if(結束條件成立) return 預設值;

return R( n 的運算式 );

}

課堂實作
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:45
b10833027呂沂真提到...: 1.
剛才我們在函數 F(n) 中又呼叫函數 F(n-1) 及 F(n-2)，像這樣在函數中又呼叫自己的寫法，就叫做「遞迴 Recursion」，而這種函數就稱為「遞迴函數 Recursive Function」。遞迴函數一開頭要先設定結束條件，否則會無窮循環下去，而遞迴呼叫自己的時候
2.using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for(int n=0;n<=50;n++)
Console.WriteLine("ff({0})={1}",n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:45
b10833033 蔡孟頻提到...: 遞回函式（recursive function）簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算（factorial）。; 2020年4月29日上午9:46
B10833034 彭仲麟提到...: 1.
遞回函式簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算。

2.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace T0429
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1)
return n;
else
return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("算費式數列程式");
for (int n = 0; n <= 40; n++)
Console.WriteLine("f({0})={1}", n, f(n));
Console.Read();
}
}
}; 2020年4月29日上午9:47
B10833001宋映嫺提到...: 1.遞回簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算。
2.↓
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace T0429
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1)
return n;
else
return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("算費式數列程式");
for (int n = 0; n <= 40; n++)
Console.WriteLine("f({0})={1}", n, f(n));
Console.Read();
}
}
}; 2020年4月29日上午9:48
B10833096林建鈞提到...: 1.遞迴就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算
2.↓
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1)
return n;
else
return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("算費式數列的程式");
for (int n = 0; n <= 40; n++)
Console.WriteLine("f({0})={1}", n, f(n));
Console.Read();

}
}
}; 2020年4月29日上午9:48
B10833073毛聖翔提到...: 說明：費式數列的前兩項為 1、1，之後的每一項為前兩項之和，即 Fn=Fn-1+Fn-2，費式數列的前 10 項為：1、1、2、3、5、8、13、21、34、55。由使用者輸入一個正數數 n ( n < 40 )，計算出費式數列的第 n 項之值並輸出之。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);

}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:51
B10833028 提到...: 1.遞回函數簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算。
階層聽起來可能很陌生，但是大家高中數學一定接觸過，例如 5! = 5 x 4 x 3 x 2 x 1。
2.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("你好");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:51
B10833029 余柏翰提到...: 所謂的遞迴函式，簡單地說就是一個呼叫自己的函式。
每一個 C 程式都是由函式組成的，由 main() 函式開始執行， main() 函式處理整個問題，為了降低程式的複雜度，通常將問題依其特性分解為許多部份， main() 函式呼叫許多獨立的函式來解決個別的問題，一層一層地分工合作下去。; 2020年4月29日上午9:54
B10833046王子榮提到...: 說明：費式數列的前兩項為 1、1，之後的每一項為前兩項之和，即 Fn=Fn-1+Fn-2，費式數列的前 10 項為：1、1、2、3、5、8、13、21、34、55。由使用者輸入一個正數數 n ( n < 40 )，計算出費式數列的第 n 項之值並輸出之。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);

}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:54
B10833025徐郁堂提到...: 說明：費式數列的前兩項為 1、1，之後的每一項為前兩項之和，即 Fn=Fn-1+Fn-2，費式數列的前 10 項為：1、1、2、3、5、8、13、21、34、55。由使用者輸入一個正數數 n ( n < 40 )，計算出費式數列的第 n 項之值並輸出之。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);

}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:55
B10833045施明睿提到...: 說明：費式數列的前兩項為 1、1，之後的每一項為前兩項之和，即 Fn=Fn-1+Fn-2，費式數列的前 10 項為：1、1、2、3、5、8、13、21、34、55。由使用者輸入一個正數數 n ( n < 40 )，計算出費式數列的第 n 項之值並輸出之。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);

}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:56
b10833031游凱程提到...: 遞回函式（recursive function）簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算（factorial）。
階層聽起來可能很陌生，但是大家高中數學一定接觸過，例如 5! = 5 x 4 x 3 x 2 x 1。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace fibomacci
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:56
B10833004黃薰田提到...: 說明：費式數列的前兩項為 1、1，之後的每一項為前兩項之和，即 Fn=Fn-1+Fn-2，費式數列的前 10 項為：1、1、2、3、5、8、13、21、34、55。由使用者輸入一個正數數 n ( n < 40 )，計算出費式數列的第 n 項之值並輸出之。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);

}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:56
B10833083 夏湘琳提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine();
for (int n = 0; n <= 50; n++)
Console.WriteLine("f({0}={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:57
B10833030 提到...: 1.又譯為遞歸，在數學與電腦科學中，是指在函數的定義中使用函數自身的方法。
遞迴一詞還較常用於描述以自相似方法重複事物的過程。

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("費式數列");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:59
b10833037沈泉澔提到...: 遞回函式（recursive function）簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算（factorial）。
階層聽起來可能很陌生，但是大家高中數學一定接觸過，例如 5! = 5 x 4 x 3 x 2 x 1。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace fibomacci
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:59
b10833037沈泉澔提到...: 遞回函式（recursive function）簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算（factorial）。
階層聽起來可能很陌生，但是大家高中數學一定接觸過，例如 5! = 5 x 4 x 3 x 2 x 1。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace fibomacci
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:59
b10833037沈泉澔提到...: 遞回函式（recursive function）簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算（factorial）。
階層聽起來可能很陌生，但是大家高中數學一定接觸過，例如 5! = 5 x 4 x 3 x 2 x 1。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace fibomacci
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午9:59
b10833014巫明憲提到...: 遞回函式（recursive function）簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算（factorial）。
階層聽起來可能很陌生，但是大家高中數學一定接觸過，例如 5! = 5 x 4 x 3 x 2 x 1。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace fibomacci
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午10:01
b10833010戴俊瑋提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1) return n;
else return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("f({0}={1}", n, f(n));
Console.Read();
}
}
}; 2020年4月29日上午10:03
D10811007 蘇鈺貽提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _12333
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n < 40; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午10:03
B10833012 何郁麒提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _12333
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n < 40; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午10:04
b10833011彭丙玉提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1) return n;
else return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("f({0}={1}", n, f(n));
Console.Read();
}
}
}; 2020年4月29日上午10:04
b10833007林文瑋提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1) return n;
else return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("f({0}={1}", n, f(n));
Console.Read();
}
}
}; 2020年4月29日上午10:05
b10833072吳仲倫提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1) return n;
else return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("f({0}={1}", n, f(n));
Console.Read();
}
}
}; 2020年4月29日上午10:05
b10833010戴俊瑋提到...: 之所以能夠透過遞回函式，是因為函式堆疊（stack）在執行時有一個特性，當某個函式呼叫另一個函式時，需要等到裡面的函式執行完產生結果後，才會繼續回來執行自己的函式內容，而這樣的情況也被稱作後進先出（Last in First Out, LIFO）; 2020年4月29日上午10:05
b10833011彭丙玉提到...: 之所以能夠透過遞回函式，是因為函式堆疊（stack）在執行時有一個特性，當某個函式呼叫另一個函式時，需要等到裡面的函式執行完產生結果後，才會繼續回來執行自己的函式內容，而這樣的情況也被稱作後進先出（Last in First Out, LIFO）; 2020年4月29日上午10:06
b10833007林文瑋提到...: 之所以能夠透過遞回函式，是因為函式堆疊（stack）在執行時有一個特性，當某個函式呼叫另一個函式時，需要等到裡面的函式執行完產生結果後，才會繼續回來執行自己的函式內容，而這樣的情況也被稱作後進先出（Last in First Out, LIFO）; 2020年4月29日上午10:06
b10833072吳仲倫提到...: 之所以能夠透過遞回函式，是因為函式堆疊（stack）在執行時有一個特性，當某個函式呼叫另一個函式時，需要等到裡面的函式執行完產生結果後，才會繼續回來執行自己的函式內容，而這樣的情況也被稱作後進先出（Last in First Out, LIFO）; 2020年4月29日上午10:06
b10815036李宥陞提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _12333
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n < 40; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午10:12
b10833038陳冠傑提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _12333
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n < 40; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午10:13
b10833044范光祐提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _12333
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n < 40; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午10:13
b10833016余竺瑾提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _12333
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n < 40; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午10:20
b10833019葉劉辰提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _12333
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n < 40; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午10:20
b10815106林子豪提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _12333
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1) return n;
else return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n < 40; n++)
Console.WriteLine("ff({0})={1}", n, ff(n));
Console.Read();
}
}
}; 2020年4月29日上午10:21
B10833022 許家銘提到...: 1. 何謂遞迴函數？
遞迴函數的定義，就是以自己本身來呼叫自己本身，如果沒有終止條件，程式是跑不完的，所以需要包含終止條件與遞迴條件兩個部份。
之所以能夠透過遞回函式，是因為函式堆疊（stack）在執行時有一個特性，當某個函式呼叫另一個函式時，需要等到裡面的函式執行完產生結果後，才會繼續回來執行自己的函式內容。

2. 實作費氏數列，用遞迴方法
namespace fib
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費氏數列的程式");
for (int n=0;n<=40;n++)
Console.WriteLine("ff({0})={1}",n,ff(n));
Console.Read();
}
}
}; 2020年4月29日上午10:25
B10833006朱軒廣提到...: namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if(n == 0 || n == 1) return n;
else return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, f(n));
Console.Read();
}

}

}; 2020年4月29日上午10:25
B10815088徐仁祥提到...: namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if(n == 0 || n == 1) return n;
else return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, f(n));
Console.Read();
}

}

}; 2020年4月29日上午10:29
D10811007 蘇鈺貽提到...: 簡單地說就是一個呼叫自己的函式。
每一個 C 程式都是由函式組成的，由 main() 函式開始執行， main() 函式處理整個問題，為了降低程式的複雜度，通常將問題依其特性分解為許多部份， main() 函式呼叫許多獨立的函式來解決個別的問題，一層一層地分工合作下去。; 2020年4月29日上午10:29
B10833012 何郁麒提到...: 遞回函式（recursive function）簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算（factorial）。
階層聽起來可能很陌生，但是大家高中數學一定接觸過，例如 5! = 5 x 4 x 3 x 2 x 1。; 2020年4月29日上午10:29
b10833084 詹祐宗提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _123
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1)
return n;
else
return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("費氏數列");
for (int n = 0; n <= 40; n++)
Console.WriteLine("f({0})={1}", n, f(n));
Console.Read();
}
}
}

在函數 F(n) 中又呼叫函數 F(n-1) 及 F(n-2)，像這樣在函數中又呼叫自己的寫法，就叫做「遞迴 Recursion」，而這種函數就稱為「遞迴函數 Recursive Function」。遞迴函數一開頭要先設定結束條件，否則會無窮循環下去，而遞迴呼叫自己的時候，必須改變它的參數，例如：
int R(int n)

{

if(結束條件成立) return 預設值;

return R( n 的運算式 );

}; 2020年4月29日上午10:30
b10815036李宥陞提到...: 所謂的遞迴函式，簡單地說就是一個呼叫自己的函式。
每一個 C 程式都是由函式組成的，由 main() 函式開始執行， main() 函式處理整個問題，為了降低程式的複雜度，通常將問題依其特性分解為許多部份， main() 函式呼叫許多獨立的函式來解決個別的問題，一層一層地分工合作下去。因此函式呼叫其它函式是理所當然的，但是呼叫自己會不會有些矛盾呢?; 2020年4月29日上午10:31
b10833038陳冠傑提到...: 所謂的遞迴函式，簡單地說就是一個呼叫自己的函式。
每一個 C 程式都是由函式組成的，由 main() 函式開始執行， main() 函式處理整個問題，為了降低程式的複雜度，通常將問題依其特性分解為許多部份， main() 函式呼叫許多獨立的函式來解決個別的問題，一層一層地分工合作下去。因此函式呼叫其它函式是理所當然的，但是呼叫自己會不會有些矛盾呢?; 2020年4月29日上午10:31
b10833044范光祐提到...: 所謂的遞迴函式，簡單地說就是一個呼叫自己的函式。
每一個 C 程式都是由函式組成的，由 main() 函式開始執行， main() 函式處理整個問題，為了降低程式的複雜度，通常將問題依其特性分解為許多部份， main() 函式呼叫許多獨立的函式來解決個別的問題，一層一層地分工合作下去。因此函式呼叫其它函式是理所當然的，但是呼叫自己會不會有些矛盾呢?; 2020年4月29日上午10:31
b10833016余竺瑾提到...: 所謂的遞迴函式，簡單地說就是一個呼叫自己的函式。
每一個 C 程式都是由函式組成的，由 main() 函式開始執行， main() 函式處理整個問題，為了降低程式的複雜度，通常將問題依其特性分解為許多部份， main() 函式呼叫許多獨立的函式來解決個別的問題，一層一層地分工合作下去。因此函式呼叫其它函式是理所當然的，但是呼叫自己會不會有些矛盾呢?; 2020年4月29日上午10:31
b10833019葉劉辰提到...: 所謂的遞迴函式，簡單地說就是一個呼叫自己的函式。
每一個 C 程式都是由函式組成的，由 main() 函式開始執行， main() 函式處理整個問題，為了降低程式的複雜度，通常將問題依其特性分解為許多部份， main() 函式呼叫許多獨立的函式來解決個別的問題，一層一層地分工合作下去。因此函式呼叫其它函式是理所當然的，但是呼叫自己會不會有些矛盾呢?; 2020年4月29日上午10:32
B10833114 鍾杰廷提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if (n ==0 || n== 1) return n;
else return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("f{0}={1}", n, f(n));
Console.Read();
}
}
}; 2020年4月29日上午10:32
b10815106林子豪提到...: 所謂的遞迴函式，簡單地說就是一個呼叫自己的函式。
每一個 C 程式都是由函式組成的，由 main() 函式開始執行， main() 函式處理整個問題，為了降低程式的複雜度，通常將問題依其特性分解為許多部份， main() 函式呼叫許多獨立的函式來解決個別的問題，一層一層地分工合作下去。因此函式呼叫其它函式是理所當然的，但是呼叫自己會不會有些矛盾呢?; 2020年4月29日上午10:33
B10833114 鍾杰廷提到...: 什麼是遞回函式（recursion）
遞回函式（recursive function）簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算（factorial）。
階層聽起來可能很陌生，但是大家高中數學一定接觸過，例如 5! = 5 x 4 x 3 x 2 x 1。
之所以能夠透過遞回函式，是因為函式堆疊（stack）在執行時有一個特性，當某個函式呼叫另一個函式時，需要等到裡面的函式執行完產生結果後，才會繼續回來執行自己的函式內容，而這樣的情況也被稱作後進先出（Last in First Out, LIFO）; 2020年4月29日上午10:34
B10833041 提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
class Program
{
static int f(int n)
{
if (n == 0 || n == 1)
return n;
else
return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("f(20)=" + f(20));
Console
Console.Read();
}
}
}; 2020年4月29日上午10:48
B10833009 張恩齊提到...: 什麼是遞回函式（recursion）
遞回函式（recursive function）簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算（factorial）。
階層聽起來可能很陌生，但是大家高中數學一定接觸過，例如 5! = 5 x 4 x 3 x 2 x 1。
之所以能夠透過遞回函式，是因為函式堆疊（stack）在執行時有一個特性，當某個函式呼叫另一個函式時，需要等到裡面的函式執行完產生結果後，才會繼續回來執行自己的函式內容，而這樣的情況也被稱作後進先出（Last in First Out, LIFO）; 2020年4月29日上午10:53
B10833009 張恩齊提到...: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if (n ==0 || n== 1) return n;
else return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0;n <= 50; n++)
Console.WriteLine("f{0}={1}", n, f(n));
Console.Read();
}
}
}; 2020年4月29日上午10:53
B10833041黃柏凱提到...: 什麼是遞回函式（recursion）
遞回函式（recursive function）簡單來說就是在一個函式當中再去呼叫它自己，其中一個實際的範例就是階層的計算（factorial）。
階層聽起來可能很陌生，但是大家高中數學一定接觸過，例如 5! = 5 x 4 x 3 x 2 x 1。
之所以能夠透過遞回函式，是因為函式堆疊（stack）在執行時有一個特性，當某個函式呼叫另一個函式時，需要等到裡面的函式執行完產生結果後，才會繼續回來執行自己的函式內容，而這樣的情況也被稱作後進先出（Last in First Out, LIFO）; 2020年4月29日上午11:07
B10833018 杜立笙提到...: 數 F(n) 中又呼叫函數 F(n-1) 及 F(n-2)，像這樣在函數中又呼叫自己的寫法，就叫做「遞迴 Recursion」，而這種函數就稱為「遞迴函數 Recursive Function」。遞迴函數一開頭要先設定結束條件，否則會無窮循環下去，而遞迴呼叫自己的時候，必須改變它的參數，例如：

int R(int n)

{

if(結束條件成立) return 預設值;

return R( n 的運算式 );

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);

}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for(int n=0; n<=40; n++)
Console.WriteLine("ff({0})={1}",n,ff(n));
Console.Read();
}
}
}; 2020年4月29日上午11:08
B10833022 許家銘提到...: 1. 何謂遞迴函數？
遞迴函數的定義，就是以自己本身來呼叫自己本身，如果沒有終止條件，程式是跑不完的，所以需要包含終止條件與遞迴條件兩個部份。
之所以能夠透過遞回函式，是因為函式堆疊（stack）在執行時有一個特性，當某個函式呼叫另一個函式時，需要等到裡面的函式執行完產生結果後，才會繼續回來執行自己的函式內容。

2. 實作費氏數列，用遞迴方法
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace fib
{
class Program
{
static int ff(int n)
{
if (n == 0 || n == 1)
return n;
else
return ff(n - 1) + ff(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費氏數列的程式");
for (int n=0;n<=40;n++)
Console.WriteLine("ff({0})={1}",n,ff(n));
Console.Read();
}
}
}; 2020年4月29日上午11:08
B10833006朱軒廣提到...: 遞歸就是一個一個函式當中再去調用它自己，其中一個實際的範例就是階層的計算（階乘）。
階層聽起來可能很陌生，但是大家高中數學一定接觸過，例如5！= 5 x 4 x 3 x 2 x1。
之所以能夠透過遞進回傳函式，是因為函式堆疊（堆棧）在執行時有一個特性，當某個函式呼叫另一個函式時，需要等到裡面的函式執行完產生結果後，才會繼續回來執行自己的函式內容，而這樣的情況也被列入後進先出（LIFO後進先出）
namespace ConsoleApp1
{
class Program
{
static int f(int n)
{
if(n == 0 || n == 1) return n;
else return f(n - 1) + f(n - 2);
}
static void Main(string[] args)
{
Console.WriteLine("這是一個算費式數列的程式");
for (int n = 0; n <= 50; n++)
Console.WriteLine("ff({0})={1}", n, f(n));
Console.Read();
}

}

}; 2020年4月29日上午11:09
B10833083 夏湘琳提到...: 遞迴函數就是在函數的定義裏面呼叫自己的函數。遞迴函數至少需要包含終止條件與遞迴條件兩個部份。遞迴可以讓程式與數學定義相契合,程式碼較為簡潔易懂。遞迴可能會重複計算相同的東西多次,造成效能的浪費。; 2020年4月29日上午11:43
B10833023 陳姿茹提到...: 遞迴函數就是在函數的定義裏面呼叫自己的函數。遞迴函數至少需要包含終止條件與遞迴條件兩個部份。遞迴可以讓程式與數學定義相契合,程式碼較為簡潔易懂。遞迴可能會重複計算相同的東西多次,造成效能的浪費。; 2020年4月29日上午11:44
B10813027唐一渝提到...: using System;

namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
static int fib(int n) {
if (n == 0 || n == 1)
//終止條件
return n;
else
return fib(n - 1) +
fib(n - 2);
}
static void Main(string[]args)
{
Console.WriteLine("f(20)=" + fib(20));
Console.Read();
}
}; 2020年4月29日上午11:45
B10833040徐嘉駿提到...: using System;

namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
static int fib(int n) {
if (n == 0 || n == 1)
//終止條件
return n;
else
return fib(n - 1) +
fib(n - 2);
}
static void Main(string[]args)
{
Console.WriteLine("f(20)=" + fib(20));
Console.Read();
}
}; 2020年4月29日上午11:45
B10813140邱東建提到...: using System;

namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
static int fib(int n) {
if (n == 0 || n == 1)
//終止條件
return n;
else
return fib(n - 1) +
fib(n - 2);
}
static void Main(string[]args)
{
Console.WriteLine("f(20)=" + fib(20));
Console.Read();
}
}; 2020年4月29日上午11:46
b10833020 黃俊浩提到...: using System;

namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
static int fib(int n) {
if (n == 0 || n == 1)
//終止條件
return n;
else
return fib(n - 1) +
fib(n - 2);
}
static void Main(string[]args)
{
Console.WriteLine("f(20)=" + fib(20));
Console.Read();
}
}; 2020年6月17日上午9:57

張貼留言

訂閱：張貼留言 (Atom)

Herr Deng桑的教學blog

網頁

herrDeng網內搜尋

Ads

2020年4月28日星期二

Ex8. 費氏數列Visual C#遞迴函式實作 Fibonacci sequence

87 則留言:

熱門文章

DengSir7 Google Display

programming

網頁

herrDeng網內搜尋

Ads

2020年4月28日 星期二

Ex8. 費氏數列Visual C#遞迴函式實作 Fibonacci sequence

87 則留言:

熱門文章

DengSir7 Google Display

programming

2020年4月28日星期二