Ch5 BFS,DFS 5-1
๐ ํ์(Search), ์๋ฃ๊ตฌ์กฐ(Data Structure)
ํ์(Search) ์ด๋ ๋ง์ ์์ ๋ฐ์ดํฐ ์ค์์ ์ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๋ ๊ณผ์ ์ ์๋ฏธํ๋ค. ํ๋ก๊ทธ๋๋ฐ์์๋ ๊ทธ๋ํ, ํธ๋ฆฌ ๋ฑ์ ์๋ฃ๊ตฌ์กฐ ์์์ ํ์์ ํ๋ ๋ฌธ์ ๋ฅผ ์์ฃผ ๋ค๋ฃฌ๋ค. ๋ํ์ ์ธ ํ์ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก DFS์ BFS๋ฅผ ๊ผฝ์ ์ ์๋๋ฐ ์ด ๋ ์๊ณ ๋ฆฌ์ฆ์ ์๋ฆฌ๋ฅผ ์ ๋๋ก ์ดํดํด์ผ ์ฝ๋ฉ ํ ์คํธ์ ํ์ ๋ฌธ์ ์ ํ์ ํ ์ ์๋ค. DFS์ BFS๋ฅผ ์ ๋๋ก ์ดํดํ๋ ค๋ฉด ๊ธฐ๋ณธ ์๋ฃ๊ตฌ์กฐ์ธ ์คํ๊ณผ ํ์ ๋ํ ์ดํด๊ฐ ํ์ํ๋ค
์๋ฃ๊ตฌ์กฐ(Data Structure) ๋ โ๋ฐ์ดํฐ๋ฅผ ํํํ๊ณ ๊ด๋ฆฌํ๊ณ ์ฒ๋ฆฌํ๊ธฐ ์ํ ๊ตฌ์กฐโ๋ฅผ ์๋ฏธํ๋ค. ๊ทธ์ค ์คํ๊ณผ ํ๋ ์๋ฃ๊ตฌ์กฐ์ ๊ธฐ์ด ๊ฐ๋ ์ผ๋ก ๋ค์์ ๋ ํต์ฌ์ ์ธ ํจ์๋ก ๊ตฌ์ฑ๋๋ค.
์ฝ์ (push) : ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๋ค. ์ญ์ (pop) : ๋ฐ์ดํฐ๋ฅผ ์ญ์ ํ๋ค.
์คํ๊ณผ ํ๋ฅผ ์ฌ์ฉ์ ์ฝ์ ,์ญ์ ์ด์ธ ์ค๋ฒํ๋ก์ ์ธ๋ํ๋ก๋ ๊ณ ๋ฏผํด์ผํ๋ค.
- ์ค๋ฒํ๋ก(Overflow):ํน์ ์๋ฃ๊ตฌ์กฐ๊ฐ ์์ฉํ ์ ์๋ ๋ฐ์ดํฐ์ ํฌ๊ธฐ๋ฅผ ์ด๋ฏธ ๊ฐ๋ ์ฐฌ ์ํ์์ ์ฝ์ ์ฐ์ฐ ์ํ์ ๋ฐ์.
- ์ธ๋ํ๋ก(Underflow):ํน์ ์๋ฃ๊ตฌ์กฐ์ ๋ฐ์ดํฐ๊ฐ ์ ํ ๋ค์ด ์์ง ์์ ์ํ์์ ์ญ์ ์ฐ์ฐ ์ํ ์ํ์ ๋ฐ์.
์คํ(Stack)
์คํ์ ๋ฐ์ค ์๊ธฐ์ ๋น์ ํ ์ ์๋ค. ํ์ ์ ์ถ(FILO) ๊ตฌ์กฐ์ด๋ค.
- stack.top(): ์คํ์ ๊ฐ์ฅ ์ ๋ฐ์ดํฐ๋ฅผ ๋ฐํ
- stack.pop(): ์คํ์ ๊ฐ์ฅ ์ ๋ฐ์ดํฐ๋ฅผ ์ญ์
- stack.push():์คํ์ ๊ฐ์ฅ ์(top) ์๋ฆฌ ์์(top = top + 1) ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์์ฑ ํ ๋ฐ์ดํฐ x ๋ฃ๊ธฐ
- stack.empty(): ์คํ์ด ๋น์๋ค๋ฉด 1, ์๋๋ฉด 0์ ๋ฐํ
stack = []
stack.append(5)
stack.append(2)
stack.append(3)
stack.pop()
print(stack)
# --> [5, 2]
ํ(Queue)
ํ๋ ๋๊ธฐ ์ค์ ๋น์ ํ ์ ์๋ค. ์ ์ ์ ์ถ(FIFO) ๊ตฌ์กฐ์ด๋ค.
- ํ ๊ตฌํํ ๋๋ collections ๋ชจ๋์์ ์ ๊ณตํ๋ deque ์ฌ์ฉ.
- deque๋ ์คํ๊ณผ ํ ์ฅ์ ์ ๋ชจ๋ ์ฑํํ ๊ฒ.
- ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ ๋นผ๋ ์๋๊ฐ ๋ฆฌ์คํธ ์๋ฃํ์ ๋นํด ํจ์จ์ ์ด๋ฉฐ, queue ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ณด๋ค ๊ฐ๋จํจ.
- ์ฝ๋ฉ ํ
์คํธ์์๋ collections ๋ชจ๋๊ณผ ๊ฐ์ ๊ธฐ๋ณธ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฌ์ฉ์ ํ์ฉ.
- Enqueue: ํ ๋งจ ๋ค์ ์ด๋ ํ ์์ ์ถ๊ฐ
- Dequeue: ํ ๋งจ ์์ชฝ์ ์์ ์ญ์
- Peek: front์ ์์นํ ๋ฐ์ดํฐ๋ฅผ ์ฝ์
- front: ํ์ ๋งจ ์์ ์์น (์ธ๋ฑ์ค)
- rear: ํ์ ๋งจ ๋ค์ ์์น(์ธ๋ฑ์ค)
from collections import deque
# ํ ๊ตฌํ์ ์ํด deque ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฌ์ฉ
queue = deque(5)
queue = deque(2)
queue = deque(3)
print(queue)
# --> [2, 3]
์ฌ๊ท ํจ์
DFS, BFS๋ฅผ ๊ตฌํํ๋ ค๋ฉด ์ฌ๊ท ํจ์๋ ์ดํดํ๊ณ ์์ด์ผ ํ๋ค. ์ฌ๊ทํจ์ Recursive Function - ์๊ธฐ ์์ ์ ๋ค์ ํธ์ถํ๋ ํจ์๋ฅผ ์๋ฏธํ๋ค.
- ์ฌ๊ท ํจ์๋ฅผ ๋ฌธ์ ํ์ด์์ ์ฌ์ฉํ ๋๋ ์ฌ๊ท ํจ์๊ฐ ์ธ์ ๋๋ ์ง, ์ข ๋ฃ ์กฐ๊ฑด์ ๊ผญ ๋ช ์ํด์ผ ํ๋ค. ์กฐ๊ฑด์ด ๋ช ์๋์ง ์์ผ๋ฉด ๋ฌดํ ํธ์ถ ๋๋ฉฐ, ์ฌ๊ท์ ์ต๋ ๊น์ด๋ฅผ ์ด๊ณผํ๊ฒ ๋๋ฉด ์ค๋ฅ๊ฐ ๋๋ค.
def recursive_function():
print("์ฌ๊ท ํจ์๋ฅผ ํธ์ถํฉ๋๋ค.")
recursive_function()
recursive_function()
ํฉํ ๋ฆฌ์ผ ์์
# ๋ฐ๋ณต์ ์ผ๋ก ๊ตฌํํ 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):
# n์ด 1 ์ดํ์ธ ๊ฒฝ์ฐ 1์ ๋ฐํ
if n <=1:
return 1
# n! = n * (n-1)!๋ฅผ ๊ทธ๋๋ก ์ฝ๋๋ก ์์ฑ
return n * factorial_recursive(n-1)
๋๊ธ๋จ๊ธฐ๊ธฐ