์ฌ๊ท
์ฌ๊ท๋ ๋ณธ๋์ ๊ฒ์ผ๋ก ๋ค์ ๋์๊ฐ๋ ๊ฒ์ ๋ง ํ๋ค๊ณ ๊ตฌ๊ธ ๊ฒ์์์ ๋ฐ์ทํด ์๋ค.
์ด ๋ง์ ์ด๋ค ์ฌ๊ฑด์ด ์๊ธฐ ์์ ์ ํฌํจํ๊ณ ๋ค์ ์๊ธฐ ์์ ์ ์ฌ์ฉํ์ฌ ์ ์๋ ๋ ์ด๋ฅผ ์ฌ๊ท์ (Recursive) ์ด๋ผ๊ณ ํ๋ค.
๋ณธ๋์ ๊ฒ์ผ๋ก ๋ค์ ๋์๊ฐ๋ค๋ ๊ฒ์ ์ข๋ ์ง๊ด์ ์ผ๋ก ๋ณด์ฌ์ฃผ์๋ฉด
์ด๋ฌํ ๊ฒ๋ค์ด ๋ฐ๋ก ์ฌ๊ท์ด๋ค.
์ฌ๊ท ํธ์ถ
ํ๋ก๊ทธ๋๋ฐ์์๋ ์ด๋ฐ ์ฌ๊ท์ ํจ๊ณผ๋ฅผ ์ด์ฉํ๋ฉด ์ข ๋ ๊ฐ๊ฒฐํ ํ๋ก๊ทธ๋๋ฐ์ ๊ตฌ์ฌํ ์ ์๋๋ฐ ์ฌ๊ท ํธ์ถ์ ๊ฐ์ฅ ์ ํํํ ์ ์๋ ๊ฒ์ด ํฉํ ๋ฆฌ์ผ ์ด๋ค.
ํฉํ ๋ฆฌ์ผ
ํฉํ ๋ฆฌ์ผ์ 1๋ถํฐ N ๊น์ง์ ๋ชจ๋ ์๋ฅผ ๊ณฑํ๋ ๊ฒ์ธ๋ฐ, ๋ค์๊ณผ ๊ฐ์ด ๋๋ํ๋ก ํฉํ ๋ฆฌ์ผ์ ์ ์ํ๋ค.
์ด ๊ณผ์ ์ ์ฝ๋๋ก ๋ง๋ค์ด ๋ณด์๋ฉด ๋ค์๊ณผ ๊ฐ๋ค
์ฌ๊ท ํธ์ถ์ ์ฌ์ฉํ์ง ์์ ํฉํ ๋ฆฌ์ผ ํจ์
class Main {
int factorialNonR(int num){
int ans = 1;
for (int i = 1; i <= num; i++) {
ans = ans * i;
}
return ans;
}
}
์์ ๊ฐ์ด ์ฌ๊ท ํธ์ถ์ ์ฌ์ฉํ์ง ์์ผ๋ฉด for๋ฌธ์ ์ด์ฉํ์ฌ i
๋ถํฐ 1 ๊น์ง์ ๋ชจ๋ ๊ณฑ์ ans
๋ผ๋ ๋ณ์์ ์ ์ฅํ๊ณ return ํ๊ฒ ๋๋ค.
ํ์ง๋ง ์ฌ๊ท๋ฅผ ์ฌ์ฉํ๋จ๋ค๋ฉด ๋์ฑ ๊ฐ๊ฒฐํ๊ณ ์ง๊ด์ ์ธ ์ฝ๋๊ฐ ๋ ๊ฒ์ด๋ค.
์ฌ๊ท ํธ์ถ์ ์ฌ์ฉํ ํฉํ ๋ฆฌ์ผ ํจ์
class Main{
int factorial(int num){
if(num > 0) return num * factorial(num-1);
else return 1;
}
}
if์ ์์ ๋ณด๋ฉด return ์ ํ๋๋ฐ ํ์ฌ์ num
๊ณผ factorial(num-1)
์ ํธ์ถ ๊ฒฐ๊ณผ๋ฅผ ๊ณฑํ๋๋ฐ, ๋ factorial(num-1)
์ factorial(num-1) * factorial(num-2)
๋ก ๋๋ ์ง ์ ์๋ค.
์ ์ ์ํํ๋ค๊ฐ n
์ด 0์ด ๋๋ ์๊ฐ 1์ ๋ฆฌํดํด์ ๋ค์ ์ํฅ์์ผ๋ก ์ฌ๋ผ๊ฐ๋ค.
๋๊ธ