ํ์ = Search
๋ง์ ์์ ๋ฐ์ดํฐ ์ค์์ ์ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๋ ๊ณผ์
๊ทธ๋ํ, ํธ๋ฆฌ ๋ฑ์ ์๋ฃ๊ตฌ์กฐ ์์์ ํ์์ ํ๋ ๋ฌธ์ ๋ฅผ ์์ฃผ ๋ค๋ฃธ
๋ํ์ ์ธ ํ์ ์๊ณ ๋ฆฌ์ฆ
- DFS
- BFS
๊ธฐ๋ณธ ์ง์ : ์คํ, ํ, ์ฌ๊ท ํจ์
์๋ฃ ๊ตฌ์กฐ = Data Structure
๋ฐ์ดํฐ๋ฅผ ํํํ๊ณ ๊ด๋ฆฌํ๊ณ ์ฒ๋ฆฌํ๊ธฐ ์ํ ๊ตฌ์กฐ
์คํ๊ณผ ํ๋ ์๋ฃ๊ตฌ์กฐ์ ๊ธฐ์ด ๊ฐ๋ ์ด๋ค
๋ ํจ์๋ก ์ด๋ค์ง๋ค(Push, Pop)
- Push๋ ์ฝ์ ์ผ๋ก, ๋ฐ์ดํฐ๊ฐ ๋ค์ด๊ฐ
- Pop์ ์ญ์ ๋ก, ๋ฐ์ดํฐ๊ฐ ์ญ์ ๋จ
์ค์ ๋ก๋ ์คํ, ํ๋ฅผ ์ฌ์ฉ์ ๋ค๋ฅธ ๊ฒฝ์ฐ์ ์๋ก ์ค๋ฒํ๋ก ๋๋ ์ธ๋ํ๋ก๋ฅผ ๊ณ ๋ คํด์ผํจ
์ค๋ฒํ๋กOverflow ๋ ํน์ ํ ์๋ฃ๊ตฌ์กฐ๊ฐ ์์ฉํ ์ ์๋ ๋ฐ์ดํฐ ํฌ๊ธฐ๋ฅผ ์ด๋ฏธ ๊ฐ๋ ์ฐฌ ์ํ์์ ์ฝ์ ๋ ๊ฒฝ์ฐ์ ์ฐ์ฐ์ด ์ํ๋๋ฉด์ ๋ฐ์ํจ
์ฆ, ์ ์ฅ ๊ณต๊ฐ์ ๋ฒ์ด๋ ๋ฐ์ดํฐ๊ฐ ๋์ณํ๋ฅผ ๋ ๋ฐ์
์ธ๋ํ๋กUnderflow๋ ํน์ ํ ๋ฐ์ดํฐ๊ฐ ์ ํ ๋ค์ด ์์ง ์์ ์ํ์์ ์ญ์ ์ฐ์ฐ ์ํ์ ๋ฐ์ดํฐ๊ฐ ์ ํ ์๊ธฐ์ ๋ฐ์ํจ
Stack ์คํ
๋ฐ์ค ์๊ธฐ์ ์ผ์ข ์ด๋ค
๋ฐ์ค๋ ์๋์์๋ถํฐ ์๋ก ์ฐจ๊ณก์ฐจ๊ณก ์๋๋ค
๊ทธ๋ฆฌ๊ณ ์๋์ ์๋ ๋ฐ์ค๋ฅผ ์น์ฐ๊ธฐ ์ํด์ ์์ ์๋ ๋ฐ์ค๋ฅผ ๋จผ์ ๋ด๋ฆฐ๋ค
์ด๋ฌํ ๊ตฌ์กฐ๋ฅผ ์ ์ ํ์ถFirst in Last out ๊ตฌ์กฐ ๋๋ ํ์ ์ ์ถLast in First Out ์ด๋ผ๊ณ ํ๋ค
stack = []
# ์ฝ์
- ์ฝ์
- ์ฝ์
- ์ญ์ - ์ฝ์
- ์ฝ์
- ์ญ์
stack.append(1)
stack.append(2)
stack.append(3)
stack.pop()
stack.append(4)
stack.append(5)
stack.pop()
print(stack) # ์ตํ๋จ ์์๋ถํฐ ์ถ๋ ฅ
print(stack[::-1]) # ์คํ ์ต์๋จ ์์๋ถํฐ ์ถ๋ ฅ
ํ
๋๊ธฐ์ค์ ๋น์ ํ ์ ์์
๋จผ์ ์จ ์ฌ๋์ด ๋จผ์ ๋ค์ด๊ฐ๋ ๊ตฌ์กฐ
๊ณต์ ํ ์๋ฃ๊ตฌ์กฐ๋ผ ๋น์ ๋๋ค
์ ์ ์ ์ถ ๊ตฌ์กฐ์ด๋ค
First in First out
# ๋ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
from collections import deque
# ํ(Queue) ๊ตฌํ์ ์ํด deque ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฌ์ฉ
queue = deque()
# ์ฝ์
- ์ฝ์
- ์ฝ์
- ์ญ์ - ์ฝ์
- ์ฝ์
- ์ญ์
queue.append(1)
queue.append(2)
queue.append(3)
queue.popleft()
queue.append(4)
queue.append(5)
queue.popleft()
print(queue) # ๋จผ์ ๋ค์ด์จ ์์๋๋ก ์ถ๋ ฅํ๊ธฐ
queue.reverse() # ๋ค์ ์ถ๋ ฅ์ ์ํด ์ญ์์ผ๋ก ๋ฐ๊พธ๊ธฐ
print(queue) # ๋์ค์ ๋ค์ด์จ ์์๋ถํฐ ์ถ๋ ฅํ๊ธฐ
deque ๋ ์คํ๊ณผ ํ์ ์ฅ์ ์ ๋ชจ๋ ์ฑํํ์ผ๋ฉฐ, ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ ๋นผ๋ ์๋๊ฐ ๋ฆฌ์คํธ ์๋ฃํ์ ๋นํด ํจ์จ์ ์ด๊ณ queue ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ด์ฉํ๋ ๊ฒ๋ณด๋ค ๋ ๊ฐ๋จํจ
์ฌ๊ทํจ์ Recursive Function
์๊ธฐ ์์ ์ ๋ค์ ํธ์ถํ๋ ํจ์
ํ๋ํธ ๊ตฌ์กฐ์ ์ ์ฌ Fractal
# ์ฌ๊ทํจ์
print('์ฌ๊ทํจ์')
def recursive_function(n):
_curr, _next= 0, 1
for _ in range(n+1):
yield _curr
_curr, _next = _next, _curr + _next
fib = recursive_function(10)
for i, v in enumerate(fib):
print('ํผ๋ณด๋์น ์์ด({}) : {}'.format(i, str(v)))
def recursive_function1(i):
# 10๋ฒ์งธ ์ถ๋ ฅ์ ์ข
๋ฃ๋๋๋ก ์กฐ๊ฑด ๋ช
์
if i == 10:
return
print(i, '๋ฒ์งธ ์ฌ๊ท ํจ์์์', i + 1, '๋ฒ์งธ ์ฌ๊ท ํจ์๋ฅผ ํธ์ถํฉ๋๋ค.')
recursive_function1(i+1)
print(i, '๋ฒ์งธ ์ฌ๊ท ํจ์๋ฅผ ์ข
๋ฃํฉ๋๋ค')
recursive_function1(1)
6๋ฒ์งธ ๋ผ์ธ์์ ์ฌ๊ท๊ฐ ์ํ๋๋ฉด์ ๊ฒฐ๊ณผ๋ ์๋์ ๊ฐ๋ค.
ํฉํ ๋ฆฌ์ผ - ์ฌ๊ทํจ์
# ํฉํ ๋ฆฌ์ผ ํ๊ธฐ - 2๊ฐ์ง ๋ฐฉ๋ฒ
def factorial_iterative(n):
result = 1
# 1๋ถํฐ n๊น์ง์ ์๋ฅผ ์ฐจ๋ก๋๋ก ๊ณฑํ๊ธฐ
for i in range(1, n + 1):
result *= i
return result
print(factorial_iterative(4))# ์ฌ๊ทํจ์๋ฅผ ์ฐ์ง ์์ ๊ฒฝ์ฐ
def factorial_recursive(n):
if n <= 1:
return 1
return n * factorial_recursive(n-1)
print(factorial_recursive(4)) # ์ฌ๊ทํจ์๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ
์ฌ๊ทํจ์ ์ฝ๋๊ฐ ๋ฐ๋ณต๋ฌธ ๋ณด๋ค ๊ฐ๊ฒฐํ ์ฝ๋์ด๋ค.
์ข ๋ฃ ์กฐ๊ฑด์ if ๋ฌธ์ ํตํด ์ค์ ํ๋ค.
๋ํ if ์กฐ๊ฑด๋ฌธ์ ์๋ชป๋ ์ ๋ ฅ์ ๋ฐ์์ ๋, ์ค๋ฅ๋ก ์ธ์งํ ์ ์๊ฒ ๋ง๋๋ ์ฅ์น๋ ์ถ๊ฐํ ์ ์์ ๊ฒ์ด๋ค.(์ถํ์)
'๐๏ธ์ํํธ์จ์ด > ๐ปpython' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ์ด์ฌ ๊ฐ๋จํ ํ๋ก๊ทธ๋จ ์ฝ๋ - ์ซ์ ๋ง์ถ๊ธฐ (0) | 2022.06.15 |
---|---|
ํ์ด์ฌ์์ ์์๋๋ฉด ์ข์ ๊ธฐ๋ฅ๋ค (0) | 2022.06.14 |
Python ์๊ณ ๋ฆฌ์ฆ - ๊ตฌํ 4ํ : ์์คํ ๊ฐ๋ฐ (0) | 2022.04.22 |
Python ์๊ณ ๋ฆฌ์ฆ - ๊ตฌํ 3ํ:์์ค ๋์ดํธ ์๊ณ ๋ฆฌ์ฆ (0) | 2022.04.21 |
Python ์๊ณ ๋ฆฌ์ฆ - ๊ตฌํ 2ํ:์๊ฐ ์๊ณ ๋ฆฌ์ฆ (0) | 2022.04.20 |