์ฌ๊ท๋?
์ด๋ค ์ฌ๊ฑด์ด ์๊ธฐ ์์ ์ ํฌํจํ๊ณ ์๊ฑฐ๋ ๋๋ ์๊ธฐ ์์ ์ ์ฌ์ฉํ์ฌ ์ ์ํ๊ณ ์์ ๋
์ด๋ฅผ ์ฌ๊ท์ (recursive)์ด๋ผ๊ณ ํ๋ค.
ํฉํ ๋ฆฌ์ผ ๊ตฌํ๊ธฐ(n!)
factorial
ํฉํ ๋ฆฌ์ผ(n!) โข 0! = 1
โข n > 0์ด๋ฉด n! = n ร (n โ 1)!
1
2
10! = 10 x 9!
9! = 9 x 8!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*
ํฉํ ๋ฆฌ์ผ๊ฐ์ ์ฌ๊ท์ ์ผ๋ก ๊ตฌํจ
*/
static int factorial(int n) {
if (n > 0)
return n * factorial(n - 1);
else
return 1;
}
/*
ํฉํ ๋ฆฌ์ผ๊ฐ์ ์กฐ๊ฑด ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ๊ตฌํ
*/
return (n > 0) ? n * factorial(n - 1) : 1;
โํฉํ ๋ฆฌ์ผ๊ฐ์ ๊ตฌํ๋ ์โ๋ ์ฌ๊ท์ ์๋ฆฌ๋ฅผ ์ดํดํ๊ธฐ์๋ ์ข์ง๋ง
ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ ์๋๋ค.
์ฌ๊ท ํธ์ถ
- โ์๊ธฐ ์์ ๊ณผ ๋๊ฐ์ ๋ฉ์๋โ๋ฅผ ํธ์ถ
factorial ๋ฉ์๋๋
n - 1์ ํฉํ ๋ฆฌ์ผ๊ฐ์ ๊ตฌํ๊ธฐ ์ํด ๋ค์ factorial ๋ฉ์๋๋ฅผ ํธ์ถํ๋ค.
์ด๋ฌํ ๋ฉ์๋ ํธ์ถ ๋ฐฉ์์ ์ฌ๊ท ํธ์ถ(recursive call)์ด๋ผ๊ณ ํ๋ค.
์ง์ ์ฌ๊ท์ ๊ฐ์ ์ฌ๊ท
- ์ง์ (direct) ์ฌ๊ท
- ์์ ๊ณผ ๋์ผํ ๋ฉ์๋๋ฅผ ํธ์ถ๋ค( a ).
- ๊ฐ์ (indirect) ์ฌ๊ท๋
- ๋ฉ์๋ a๊ฐ ๋ฉ์๋ b๋ฅผ ํธ์ถํ๊ณ ,
๋ค์ ๋ฉ์๋ b๊ฐ ๋ฉ์๋ a๋ฅผ ํธ์ถํ๋ ๊ตฌ์กฐ( b ).
1-3. ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ
๋ ์ ์์ ์ต๋๊ณต์ฝ์(greatest common divisor)๋ฅผ ์ฌ๊ท์ ์ผ๋ก ๊ตฌํ๋ ๋ฐฉ๋ฒ
์ปดํจํฐ๋ฅผ ์ด์ฉํด ์ต๋๊ณต์ฝ์๋ฅผ ์ฐพ์ ๋๋, ์์ธ์๋ถํด๋ฅผ ํ๊ธฐ ๋ณด๋ค๋
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ด๋ผ๋ ์๊ณ ๋ฆฌ์ฆ(๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด ์ ํด์ง ์ ์ฐจ)๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ๋น ๋ฅด๋ค.
1
2
3
4
5
6
7
// ์ ์ x, y์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ์ฌ ๋ฐํ
static int gcd(int x, int y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
2. ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ ๋ถ์
2-1. ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ ๋ถ์ํ๊ธฐ
ํํฅ์ ๋ถ์
โ๏ธ recur(3)์ ํธ์ถ ..
์ํฅ์ ๋ถ์
2-2. ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ์ ๋น์ฌ๊ท์ ํํ
๊ผฌ๋ฆฌ ์ฌ๊ท์ ์ ๊ฑฐ
์ฌ๊ท์ ์ ๊ฑฐ
2-3. ๋ฉ๋ชจํ
3. ํ๋ ธ์ด์ ํ
4. 8ํธ ๋ฌธ์
4-1. ํธ ๋ฐฐ์นํ๊ธฐ
4-2. ๋ถ๊ธฐ ์กฐ์
4-3. ๋ถ๊ธฐ ํ์ ๋ฒ
4-4. 8ํธ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ํ๋ก๊ทธ๋จ ๋ง๋ค๊ธฐ
(์ฐธ๊ณ )
- ๋์! ์๊ณ ๋ฆฌ ๊ธฐ์ด
- ์ฌ๊ท์๊ณ ๋ฆฌ์ฆ ๋ถ์
- ์ฌ๊ทํจ์์ ๊ผฌ๋ฆฌ ์ฌ๊ท
- ์ ์๋ก (1) - ์ต๋๊ณต์ฝ์, ์ต์๊ณต๋ฐฐ์, ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ
- ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์
๊ณต๋ถํ ๋ด์ฉ์ ์ฌ๋ฌ๊ธ๊ณผ ์ฑ
์ฝ์ ๋ด์ฉ์ ๋ฐํ์ผ๋ก ์ ๋ฆฌํ๊ณ ์์ต๋๋ค.
์ข์ ๊ธ๋ก ์ ์ ๊ณต๋ถ์ ๋์์ ์ฃผ์๋ ๋ถ๋ค๊ป ๊ฐ์ฌ๋๋ฆฝ๋๋ค.