๐ํ์(Search)
ํ์์ด๋ ๋ง์ ์์ ๋ฐ์ดํฐ ์ค์์ ์ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๋ ๊ณผ์ ์ ์๋ฏธํ๋ค.
ํ๋ก๊ทธ๋๋ฐ์์๋ ๊ทธ๋ํ, ํธ๋ฆฌ ๋ฑ์ ์๋ฃ๊ตฌ์กฐ ์์์ ํ์์ ํ๋ ๋ฌธ์ ๋ฅผ ์์ฃผ ๋ค๋ฃฌ๋ค.
๋ํ์ ์ธ ํ์ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก DFS(๊น์ด ์ฐ์ ํ์)๊ณผ BFS(๋๋น ์ฐ์ ํ์) ๋ ๊ฐ์ง๋ฅผ ๊ผฝ์ ์ ์๋๋ฐ, DFS์ BFS๋ฅผ ์ ๋๋ก ์ดํดํ๋ ค๋ฉด ๊ธฐ๋ณธ ์๋ฃ๊ตฌ์กฐ์ธ ์คํ๊ณผ ํ์ ๋ํ ์ดํด๊ฐ ํ์ํ๋ฏ๋ก ์คํ๊ณผ ํ, ์ฌ๊ท ํจ์๋ฅผ ๊ฐ๋จํ ์ ๋ฆฌํ๋ ค๊ณ ํ๋ค.
๐์๋ฃ๊ตฌ์กฐ(Data Structure)
์๋ฃ๊ตฌ์กฐ๋ '๋ฐ์ดํฐ๋ฅผ ํํํ๊ณ ๊ด๋ฆฌํ๊ณ ์ฒ๋ฆฌํ๊ธฐ ์ํ ๊ตฌ์กฐ' ๋ฅผ ์๋ฏธํ๋ค.
๊ทธ ์ค ์คํ๊ณผ ํ๋ ์๋ฃ๊ตฌ์กฐ์ ๊ธฐ์ด ๊ฐ๋
์ผ๋ก ๋ค์ ๋ ํต์ฌ์ ์ธ ํจ์๋ก ๊ตฌ์ฑ๋๋ค.
- ์ฝ์ (Push) : ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๋ค.
- ์ญ์ (Pop) : ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ค.
์ค์ ๋ก ์คํ๊ณผ ํ๋ฅผ ์ฌ์ฉํ ๋๋ ์ค๋ฒํ๋ก(Overflow)์ ์ธ๋ํ๋ก(Underflow)๋ฅผ ๊ณ ๋ฏผํด์ผ ํ๋ค.
- ์ค๋ฒํ๋ก(Overflow) : ๋ฐ์ดํฐ์ ํฌ๊ธฐ๊ฐ ์ด๋ฏธ ๊ฐ๋ ์ฐฌ ์ํ์์ ์ฝ์ ์ฐ์ฐ์ ์ํํ ๋ ๋ฐ์ํ๋ค.
- ์ธ๋ํ๋ก(Underflow) : ๋ฐ์ดํฐ๊ฐ ์ ํ ๋ค์ด์์ง ์์ ์ํ์์ ์ญ์ ์ฐ์ฐ์ ์ํํ ๋ ๋ฐ์ํ๋ค.
๐์คํ(Stack)
์คํ์ ์ ์
ํ์ถ(FILO) ๋๋ ํ์
์ ์ถ(LIFO) ๊ตฌ์กฐ ์ด๋ค.
๋ฐ์ค ์๊ธฐ์ ๋น์ ํ๋ฉด ์ฝ๊ฒ ์ดํดํ ์ ์๋ค.
ํ์ด์ฌ์์ ์คํ์ ์ด์ฉํ ๋๋ ๋ฐ๋ก ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ ํ์๊ฐ ์๋ค.
๊ธฐ๋ณธ ๋ฆฌ์คํธ์์ append()์ pop() ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ฉด ์คํ ์๋ฃ๊ตฌ์กฐ์ ๋์ผํ๊ฒ ๋์ํ๋ค.
append() ๋ฉ์๋๋ ๋ฆฌ์คํธ์ ๊ฐ์ฅ ๋ค์ชฝ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์
ํ๊ณ , pop() ๋ฉ์๋๋ ๋ฆฌ์คํธ์ ๊ฐ์ฅ ๋ค์ชฝ์์ ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ด๊ธฐ ๋๋ฌธ์ด๋ค.
๐ํ(Queue)
ํ๋ ์ ์
์ ์ถ(FIFO) ๊ตฌ์กฐ ์ด๋ค.
๋๊ธฐ ์ค์ ๋น์ ํ๋ฉด ์ฝ๊ฒ ์ดํดํ ์ ์๋ค.
ํ์ด์ฌ์์ ํ๋ฅผ ๊ตฌํํ ๋๋ collections ๋ชจ๋์์ ์ ๊ณตํ๋ deque ์๋ฃ๊ตฌ์กฐ๋ฅผ ํ์ฉํ์.
deque๋ ์คํ๊ณผ ํ์ ์ฅ์ ์ ๋ชจ๋ ์ฑํํ ๊ฒ์ธ๋ฐ
๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ ๋นผ๋ ์๋๊ฐ ๋ฆฌ์คํธ ์๋ฃํ์ ๋นํด ํจ์จ์ ์ด๋ฉฐ queue ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ด์ฉํ๋ ๊ฒ๋ณด๋ค ๋ ๊ฐ๋จํ๋ค.
๐์ฌ๊ท ํจ์(Recursive Function)
์ฌ๊ท ํจ์๋ ์๊ธฐ ์์ ์ ๋ค์ ํธ์ถํ๋ ํจ์๋ฅผ ์๋ฏธํ๋ค.
๊ฐ๋จํ ์ฌ๊ท ํจ์๋ ๋ค์๊ณผ ๊ฐ๋ค.
def recursive_function():
print("์ฌ๊ท ํจ์๋ฅผ ํธ์ถํฉ๋๋ค.")
recursive_function()
recursive_function()
์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด '์ฌ๊ท ํจ์๋ฅผ ํธ์ถํฉ๋๋ค.' ๋ผ๋ ๋ฌธ์์ด์ ๋ฌดํํ ์ถ๋ ฅํ๋ค. ์ฌ๊ธฐ์ ์ ์ํ revursive_function()์ด ์๊ธฐ ์์ ์ ๊ณ์ํด์ ์ถ๊ฐ๋ก ๋ถ๋ฌ์ค๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฌผ๋ก ์ด๋์ ๋ ์ถ๋ ฅํ๋ฉด ์ค๋ฅ ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํ๊ณ ๋ฉ์ถ ๊ฒ์ด๋ค.
๐ก์ฌ๊ท ํจ์์ ์ข ๋ฃ ์กฐ๊ฑด
์ฌ๊ท ํจ์๋ฅผ ๋ฌธ์ ํ์ด์์ ์ข
๋ฃ ์กฐ๊ฑด์ ๋ช
์ํ์ง ์์ผ๋ฉด ํจ์๊ฐ ๋ฌดํํ ํธ์ถ๋ ์ ์๊ธฐ ๋๋ฌธ์ ์ฌ๊ท ํจ์๊ฐ ์ธ์ ๋๋ ์ง, ์ข
๋ฃ ์กฐ๊ฑด์ ๊ผญ ๋ช
์ํด์ผ ํ๋ค.
์๋ก ๋ค์์ ์ฌ๊ท ํจ์๋ฅผ 100๋ฒ ํธ์ถํ๋ ์ฝ๋์ด๋ค.
์ฌ๊ท ํจ์ ์ด๋ฐ์ ๋ฑ์ฅํ๋ if๋ฌธ์ด ์ข
๋ฃ ์กฐ๊ฑด ์ญํ ์ ์ํํ๋ค.
def recursive_function(i):
if i == 100:
return
print(i, '๋ฒ์งธ ์ฌ๊ท ํจ์์์', i+1, '๋ฒ์งธ ์ฌ๊ท ํจ์๋ฅผ ํธ์ถํฉ๋๋ค.')
recursive_function(i+1)
print(i, '๋ฒ์งธ ์ฌ๊ท ํจ์๋ฅผ ์ข
๋ฃํฉ๋๋ค.')
recursive_function(1)
์ฌ๊ท ํจ์๋ ๋ด๋ถ์ ์ผ๋ก ์คํ ์๋ฃ๊ตฌ์กฐ์ ๋์ผํ๋ค.
๋ฐ๋ผ์ ์คํ ์๋ฃ๊ตฌ์กฐ๋ฅผ ํ์ฉํด์ผ ํ ๋ ์ฌ๊ท ํจ์๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํ๋ ์ ์๋ค.
DFS(๊น์ด ์ฐ์ ํ์)์ด ๋ํ์ ์ธ ์์ด๋ค.
์ฌ๊ท ํจ์๋ฅผ ์ด์ฉํ๋ ๋ํ์ ์์ ๋ก ํฉํ ๋ฆฌ์ผ(Factorial)๋ฌธ์ ๊ฐ ์๋ค.
ํฉํ ๋ฆฌ์ผ์ ๋ฐ๋ณต์ ์ผ๋ก ๊ตฌํํ ๋ฐฉ์๊ณผ ์ฌ๊ท์ ์ผ๋ก ๊ตฌํํ ๋ ๋ฐฉ์์ ๋น๊ตํด๋ณด์.
# ๋ฐ๋ณต์ ์ผ๋ก ๊ตฌํํ n!
def factorial_iterative(n):
result = 1
# 1๋ถํฐ n๊น์ง์ ์๋ฅผ ์ฐจ๋ก๋๋ก ๊ณฑํ๊ธฐ
for i in range(1, n+1):
result *= i
return result
# ์ฌ๊ท์ ์ผ๋ก ๊ตฌํํ n!
def factorial_recursive(n):
if n <= 1: # n์ด 1 ์ดํ์ธ ๊ฒฝ์ฐ 1์ ๋ฐํ
return 1
# n! = n * (n-1)! ๋ฅผ ๊ทธ๋๋ ์ฝ๋๋ก ์์ฑํ๊ธฐ
return n * factorial_recursive(n-1)
# ๊ฐ๊ฐ์ ๋ฐฉ์์ผ๋ก ๊ตฌํํ n! ์ถ๋ ฅ (n=5)
print('๋ฐ๋ณต์ ์ผ๋ก ๊ตฌํ:', factorial_iterative(5))
print('์ฌ๊ท์ ์ผ๋ก ๊ตฌํ:', factorial_recursive(5))
๋ฐ๋ณต์ ์ผ๋ก ๊ตฌํ: 120
์ฌ๊ท์ ์ผ๋ก ๊ตฌํ: 120
์คํ ๊ฒฐ๊ณผ๋ ๋๊ฐ์ง๋ง ๋ฐ๋ณต๋ฌธ ๋์ ์ฌ๊ท ํจ์๋ฅผ ์ฌ์ฉํ์ ๋ ์ฝ๋๊ฐ ๋ ๊ฐ๊ฒฐํ๋ค.
๊ทธ ์ด์ ๋ ์ํ์ ์ ํ์(์ฌ๊ท์)์ ๊ทธ๋๋ก ์ฝ๋์ ์ฎ๊ฒผ๊ธฐ ๋๋ฌธ์ด๋ค.
ํฉํ ๋ฆฌ์ผ์ ์ํ์ ์ ํ์์ผ๋ก ํํํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
- n์ด 0 ํน์ 1์ผ ๋ : factorial(n) = 1
- n์ด 1๋ณด๋ค ํด ๋ : factorial(n) = n x factorial(n-1)
์ ํ์์์ ์ข
๋ฃ ์กฐ๊ฑด์ ์ฐพ์ ์ ์๋๋ฐ, ์ ์์์์ ์ข
๋ฃ ์กฐ๊ฑด์ 'n์ด 0ํน์ 1์ผ ๋' ์ด๋ค.
ํฉํ ๋ฆฌ์ผ์ n์ด ์์ ์ ์์ผ ๋๋ง ์ ํจํ๊ธฐ ๋๋ฌธ์ n์ด 1 ์ดํ์ธ ๊ฒฝ์ฐ 1์ ๋ฐํํ ์ ์๊ฒ ์ฌ๊ท ํจ์๋ฅผ ์์ฑํด์ผ ํ๋ค.
n์ด 1 ์ดํ์ธ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํ์ง ์์ผ๋ฉด ์ฌ๊ท ํจ์๊ฐ ๋ฌดํํ ๋ฐ๋ณต ๋์ด ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ์ง ๋ชปํ ๊ฒ ์ด๋ค.
๋ํ n์ ๊ฐ์ผ๋ก ์์๊ฐ ๋ค์ด์์ ๋๋ ์
๋ ฅ ๋ฒ์ ์ค๋ฅ๋ก, ์ค๋ฅ ๋ฉ์์ง๋ฅผ ๋์ฐ๋๋ก ์ฝ๋๋ฅผ ์์ฑํ ์๋ ์๋ค.
๋ฐ๋ผ์ ์ฌ๊ท ํจ์ ๋ด์์ ํน์ ์กฐ๊ฑด์ผ ๋ ๋ ์ด์ ์ฌ๊ท์ ์ผ๋ก ํจ์๋ฅผ ํธ์ถํ์ง ์๊ณ ์ข
๋ฃํ๋๋ก if๋ฌธ์ ์ด์ฉํ์ฌ ๊ผญ ์ข
๋ฃ ์กฐ๊ฑด์ ๊ตฌํํด์ฃผ์ด์ผ ํ๋ค.
โป ํด๋น ํฌ์คํ
์ใ์ด๊ฒ์ด ์ทจ์
์ ์ํ ์ฝ๋ฉํ
์คํธ๋ค(๋๋๋น ์ )ใ์ฑ
๋ด์ฉ์ ๋ฐํ์ผ๋ก ์์ฑํ์์ต๋๋ค.