Recursive function, ์ฌ๊ทํจ์๋ '์ค์ค๋ก๋ฅผ ํธ์ถํ๋ ํจ์' ์ ๋๋ค.
์ค์ค๋ก๋ฅผ ํธ์ถํ๋ ๋ฐฉ๋ฒ์ ์ง์ ํธ์ถํ ์๋ ์๊ณ , ๋ค๋ฅธ ํจ์๋ฅผ ํตํด ๊ฐ์ ํธ์ถํ ์๋ ์์ต๋๋ค.
์ฌ๊ทํจ์๋ ์ด์งํ์, ํฉํ ๋ฆฌ์ผ ์ฐ์ฐ, ํผ๋ณด๋์น ์์ด ๋ฑ ์ํ์ด๋ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋ ๋ถ์ผ์์ ์์ฃผ ์ฌ์ฉ๋ฉ๋๋ค.
์ฒซ๋ฒ์งธ๋ก ํฉํ ๋ฆฌ์ผ(!)์ ์์๋ฅผ ๋ค์ด๋ณด๊ฒ ์ต๋๋ค.
์ฐ์ ํฉํ ๋ฆฌ์ผ์ด๋, '๊ทธ ์๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๋ชจ๋ ์์ ์ ์์ ๊ณฑ' ์ ๋๋ค.
0! = 1 ์ด๊ณ , n! = n * (n - 1)! ์ด๋ผ๊ณ ์ดํดํ๋ฉด ๋ฉ๋๋ค.
๊ทธ ํจ์๋ ๋ค์๊ณผ ๊ฐ์ด ์ฌ๊ทํจ์๋ฅผ ํ์ฉํ์ฌ ๊ตฌํํ ์ ์์ต๋๋ค.
// factorial function
unsigned long long factorial(unsigned long long n) {
if (n == 0)
return 1;
return n * factorial(n - 1);
}
unsigned long long ์ธ์๋ฅผ ๋ฐ์์ ๋ฐํํ๋ factorial ํจ์ ๋ด๋ถ์์,
n์ด 0์ด ์๋ ๋์๋ factorial ํจ์ ์ค์ค๋ก๋ฅผ ๋ค์ ๋ถ๋ฅด๋ ๊ฒ์ด ํ์ธ๋ฉ๋๋ค.
์ด๊ฒ์ด ๋ฐ๋ก ์ฌ๊ทํจ์ ์ ๋๋ค.
๋ค์ ์์๋ ํผ๋ณด๋์น ์์ด์ ๋๋ค.
ํผ๋ณด๋์น ์์ด์ ๋ํ ์ค๋ช ์ ๋ค์ ๋งํฌ๋ฅผ ์ฐธ์กฐํด์ฃผ์ธ์.
ํผ๋ณด๋์น ์์ด ์ญ์ ์ฌ๊ทํจ์๋ฅผ ํตํด ๊ตฌํ์ด ๊ฐ๋ฅํฉ๋๋ค.
unsigned long long fibonacci(unsigned long long n) {
if (n <= 1)
return n;
return fibonacci(n - 2) + fibonacci(n - 1);
}
int main(){
cout << fibonacci(30) << endl; // 83240
return 0;
}
์ฃผ์ ์ฌํญ
์ฌ๊ท ํจ์๋ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋ ์ ์๋ ์ค์ํ ํจ์์ ๋๋ค.
ํ์ง๋ง, ํจ์ ๋ด์์ ์ค์ค๋ก๋ฅผ ๋ค์ ํธ์ถํ๋ ๋งํผ ์ฃผ์ํด์ผ ํ ์ ๋ค์ด ์กด์ฌํฉ๋๋ค.
๋ํ์ ์ผ๋ก๋ ๋ฌดํ ๋ฐ๋ณต ๋ฌธ์ ๊ฐ ์์ต๋๋ค.
์ ์ ํ base case๋ฅผ ํตํ ๋งค์ปค๋์ฆ์ ๊ตฌ์ถํ์ง ์์ผ๋ฉด ๋ฌดํ ๋ฐ๋ณต ํจ์๊ฐ ๋ฉ๋๋ค.
๋ํ ์ฌ๊ท ํจ์๋ก ๊ตฌํ ๊ฐ๋ฅํ ๋ชจ๋ ํจ์๋ ๋ฐ๋ณต๋ฌธ์ผ๋ก๋ ๊ตฌํ์ด ๊ฐ๋ฅํฉ๋๋ค.
Stack overflow error๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํด์๋ ์ฌ๊ท ํจ์์ ๋จ์ฉ์ ์์ ํด์ผ ํฉ๋๋ค.
๋น์ฐํ๊ฒ๋ ์์ ํผ๋ณด๋์น ์์ด๊ณผ ๊ฐ์ ์ฌ๊ทํจ์๋ ํจ์ ํธ์ถ์ ์๊ฐ ์ ๋ ฅ๊ฐ์ ์์น๊ณผ ํจ๊ป ์ง์์ ์ผ๋ก ์ฆ๊ฐํฉ๋๋ค.
์ด์ ๊ฐ์ด ์ฌ๊ท ํจ์๋ ๊ฝค๋ ์์(๋ฉ๋ชจ๋ฆฌ)์ ํฌ๊ฒ ์๋ชจํ๋ ํจ์์ ๋๋ค.
์ ์ํ์ฌ ์ ์ ํ ์ํฉ์๋ง ์ฌ์ฉํด์ผ ํฉ๋๋ค.
'C++ > ํจ์ (Function)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C++] c_str() ํจ์ (0) | 2023.12.23 |
---|---|
[C++] ํจ์์์ ํฌ์ธํฐ๋ฅผ ๋ฐํํ๊ธฐ (Returning a Pointer from a Function) (1) | 2023.12.22 |
[C++] ์ฐธ์กฐ๋ก ์ ๋ฌํ๊ธฐ (Pass by Reference) (1) | 2023.12.17 |
[C++] ํจ์์ ๋ฐฐ์ด์ ๋งค๊ฐ๋ณ์๋ก ์ฌ์ฉํ ๋ (Passing Arrays To Functions) (3) | 2023.12.17 |
[C++] ํจ์ ์ค๋ฒ๋ก๋ฉ (Function Overloading) (1) | 2023.12.17 |