[์๋ฃ๊ตฌ์กฐ] ์ฌ๊ท(Recursion)
์ฌ๊ทํจ์๋?
์ฌ๊ทํจ์๋ ์ด๋ค ํจ์ func(n)์ด ์๋ค๊ณ ํ ๋, ์ด ํจ์ ๋ด๋ถ์์ ์๊ธฐ ์์ ์ ๋ค์ ํธ์ถํ๋ ํจ์๋ฅผ ์๋ฏธํ๋ค.
1) ์ฌ๊ทํจ์์ ํน์ง
์ฌ๊ท ํจ์๋
- ์๊ธฐ ์์ ์ ํธ์ถํ๋ ๋ถ๋ถ
- ์ผ์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด ํธ์ถ์ ์ ์งํ๊ณ ์ด๋ค ๊ฐ์ returnํ๋ ๋ถ๋ถ
์ด ๋ ๋ถ์ผ๋ก ๋๋์ด์ง๋ค.
๊ทธ๋ฆฌ๊ณ ํจ์ ํธ์ถ์ ๋ฉ๋ชจ๋ฆฌ์ ์คํ ์์ญ์ ์์ด๊ฒ ๋๋๋ฐ, ์คํ์ ํ์ ์ ์ถ(LIFO)๋ฐฉ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ์์ ์ฐ๋ฆฌ๋ ์๊ณ ์๋ค. ๋ฐ๋ผ์, ์๋ ํจ์๋ฅผ ์คํํ์ ๋ ์คํ ์์ญ์ ์์ด๋ ํจ์๋ ๋ค์๊ณผ ๊ฐ๋ค.
def sol(n):
if n == 5:
return
else:
return sol(n+1)
sol(0)
๐ ์ฌ๊ทํจ์ ํธ์ถ๋ง๋ค ์๋ก์ด ์คํ์ด ์๊ธด๋ค.๐ ์ฌ๊ท ํจ์์ ๋จ์ ์ n์ด ์ฆ๊ฐํ๋ฉด ์๊ฐ ๋ณต์ก๋ O(2n)๊ฐ ๊ฐํ๋ฅด๊ฒ ์ฆ๊ฐํ๋ค๋ ์ ์ ๋๋ค. (→ ์ด๋ฌํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ๋ฉ๋ชจ์ด์ ์ด์ (Memoization)์ ์ ์ฉํ ์ ์์ต๋๋ค.)โผ๏ธ ์ฌ๊ทํจ์ ํธ์ถ ์ ์ ๋ ฅ(์ธ์)๊ฐ์ด ํน์ ํจํด์ ๋ฐ๋ณตํ๊ฑฐ๋, ๋ณํ๊ฐ ์์ผ๋ฉด ๋ฌดํํ ๋ฐ๋ณตํ๊ฒ ๋๋ค. โถ์ฌ๊ทํจ์ ์ค๊ณ ์ ์ ๋ ฅ ๊ฐ์ด ์ข ๋ฃ ์กฐ๊ฑด์ผ๋ก ์๋ ดํ๋์ง ๊ผญ ํ์ธํด์ผ ํ๋ค.
2) ์ฌ๊ทํจ์ ์ง๋ ๋ฒ
1. ์์ ์ ํธ์ถํ๋ ๊ฒ์ ์ ์ง์ํค๋ ์กฐ๊ฑด์ ๋ง๋ค์ด์ผ ํ๋ค.
- ํ ๋์๋ง๋ค ํด์ผํ๋ ๊ฒ๋ค์ ์ ์ํด์, ํจ์ ๋ด๋ถ์ ์จ๋ฃ๋๋ค.
- ๋ค์ ํจ์๋ฅผ ํธ์ถํ ๋, ํ๋ผ๋ฏธํฐ๋ก ์ด๋ค ๊ฒ๋ค์ ๋๊ฒจ์ค์ผ ํ ์ง ์ ํด์ผ ํ๋ค.
์ฌ๊ทํจ์์ ์์
1. ํฉํ ๋ฆฌ์ผ
def factorial(n):
if n == 1: # n์ด 1์ผ ๋
return 1 # 1์ ๋ฐํํ๊ณ ์ฌ๊ทํธ์ถ์ ๋๋
return n * factorial(n - 1) # n๊ณผ (factorial ํจ์์ n-1์ ๋ฃ์ด์ ๋ฐํ๋ ๊ฐ)์ ๊ณฑํจ
2. ๊ฑฐ๋ญ์ ๊ณฑ
def solution2(x,n):
if n == 0:
return x
else:
return x * solution2(x,n-1)
3. ํผ๋ณด๋์น์์ด
- ํผ๋ณด๋์น ์ : ์ฒซ๋ฒ์งธ์ ๋๋ฒ์งธ ๊ฐ์ด 1์ด๊ณ ๋ค์๋ถํฐ๋ ๊ทธ ์ ์ ์์ ๊ทธ ์ ์ ์ ์๋ฅผ ๋ํ๋ ๋ฐฉ์
์ฒซ ๋ฒ์งธ ๊ฐ์ด 0์ผ๋ก ์์ํ๋ ๊ฒฝ์ฐ๋ ์์ผ๋ฉฐ ๋ค์๊ณผ ๊ฐ์ ํํ์ ์์ด์ด๋ค.
(0), 1, 1, 2, 3, 5, 8, 13, ...
def fib(n):
if n == 0:
return 0
elif n == 1 or n == 2:
return 1
else:
return fib(n - 1) + fib(n - 2)
4. ํ๋ ธ์ด์ ํ
ํ๋ ธ์ด์ ํ ๋ฌธ์ ๋ ์ฌ๊ท ํธ์ถ์ ์ด์ฉํ์ฌ ํ ์ ์๋ ๊ฐ์ฅ ์ ๋ช ํ ์์ ์ค์ ํ๋์ด๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ํ๋ก๊ทธ๋๋ฐ ์์ ์์ ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ ์์ ๋ก ๋ง์ด ์ฌ์ฉํ๋ค.
# ์
๋ ฅ : ์ฎ๊ธฐ๋ ค๋ ์๋ฐ์ ๊ฐ์ n
# ์ฎ๊ธธ ์๋ฐ์ด ํ์ฌ ์๋ ์ถ๋ฐ์ ๊ธฐ๋ฅ from_pos
# ์๋ฐ์ ์ฎ๊ธธ ๋์ฐฉ์ ๊ธฐ๋ฅ to_pos
# ์ฎ๊ธฐ๋ ๊ณผ์ ์์ ์ฌ์ฉํ ๋ณด์กฐ ๊ธฐ๋ฅ aux_pos
# ์ถ๋ ฅ : ์๋ฐ์ ์ฎ๊ธฐ๋ ์์
def hanoi(n, from_pos, to_pos, aux_pos):
if n == 1 : # ์๋ฐ ํ ๊ฐ๋ฅผ ์ฎ๊ธฐ๋ ๋ฌธ์ ๋ฉด ๊ทธ๋ฅ ์ฎ๊ธฐ๋ฉด ๋จ
print(from_pos, '->', to_pos)
return
hanoi(n - 1, from_pos, aux_pos, to_pos) # ์๋ฐ n-1๊ฐ๋ฅผ aux_pos๋ก ์ด๋(to_pos๋ฅผ ๋ณด์กฐ ๊ธฐ๋ฅ์ผ๋ก)
print(from_pos, '->', to_pos) # ๊ฐ์ฅ ํฐ ์๋ฐ์ ๋ชฉ์ ์ง๋ก ์ด๋
hanoi(n - 1, aux_pos, to_pos, from_pos) # aux_pos์ ์๋ ์๋ฐ n-1๊ฐ๋ฅผ ๋ชฉ์ ์ง๋ก ์ด๋ (from_pos๋ฅผ ๋ณด์กฐ ๊ธฐ๋ฅ์ผ๋ก)
print('n = 1')
hanoi(1, 1, 3, 2) # ์๋ฐ ํ ๊ฐ๋ฅผ 1๋ฒ ๊ธฐ๋ฅ์์ 3๋ฒ ๊ธฐ๋ฅ์ผ๋ก ์ด๋
n = 1
1 -> 3
print('n = 2')
hanoi(2, 1, 3, 2) # ์๋ฐ ํ ๊ฐ๋ฅผ 1๋ฒ ๊ธฐ๋ฅ์์ 3๋ฒ ๊ธฐ๋ฅ์ผ๋ก ์ด๋
n = 2
1 -> 2
1 -> 3
1 -> 3
์ด ๋ฌธ์ ์ ํต์ฌ์ 3๊ฐ์ง ์๊ธฐ๋ฅ์ 1,2,3 ์ด๋ผ๊ณ ์ ํ๋๋ฐ ์ด ๋ป์ ์์,๋ณด์กฐ,๋ชฉํ ๊ธฐ๋ฅ 3๊ฐ์ง์ด๋ค.
์ด ๊ธฐ๋ฅ ๋ฒํธ๋ค์ ํตํด์ ์๋ฐ์ด ์ด๋ป๊ฒ ์ด๋๋๋์ง๋ฅผ ๊ธฐ๋ฅ ๋ฒํธ๋ก ๋ํ๋ด๋ ๊ฒ!
๐ก ํ๋ ธ์ด์ ํ ์๊ณ ๋ฆฌ์ฆ ํต์ฌ 1. ์ ์ผ ํฐ ์๋ฐ์ ์ ์ธํ ๋๋จธ์ง ์๋ฐ๋ค์ ๋ณด์กฐ ๊ธฐ๋ฅ์ผ๋ก ๋ณด๋ธ๋ค๋ ๊ฒ (์ฌ๊ท๋ก ๊ตฌํ) 2. ๊ทธ ๋ค์ ์์ ๊ธฐ๋ฅ์ ๋ธ๋ ํผ์ ์๋ ์ ์ผ ํฐ ์๋ฐ์ด ์ฒ์์ ๋ชฉํ ๊ธฐ๋ฅ์ผ๋ก ๊ฐ๋ค๋ ๊ฒ (์ด๋ print๋ก ๊ตฌํ) 3. ๋ณด์กฐ ๊ธฐ๋ฅ์ ์๋ ์๋ฐ๋ค(n-1๊ฐ์ ์๋ฐ๋ค)์ ๊ทธ๋๋ก ๋ชฉํ๊ธฐ๋ฅ์ผ๋ก ๋ณด๋ด๋ ๊ฒ (๋ค์ ์ฌ๊ท๋ก ๊ตฌํ)
'Computer Science > Data Structure' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๋ฃ๊ตฌ์กฐ] ํธ๋ฆฌ (Tree) (0) | 2022.04.26 |
---|---|
[์๋ฃ๊ตฌ์กฐ] ์ฐ๊ฒฐ๋ฆฌ์คํธ(Linked List) (0) | 2022.03.11 |
[์๋ฃ๊ตฌ์กฐ] ํ(Queue) (0) | 2022.03.10 |
[์๋ฃ๊ตฌ์กฐ] ์คํ(Stack) (0) | 2022.03.10 |
[์๋ฃ๊ตฌ์กฐ] ์๋ฃ๊ตฌ์กฐ์ ์๊ณ ๋ฆฌ์ฆ (0) | 2022.03.08 |