์ด์งํ์ ์๊ณ ๋ฆฌ์ฆ์ ์ ํ ํ์ ์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ฌ๋ฆฌ, ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ฅผ ์ ์ ๋ก ํ๋ค.
์ ๋ ฌ๋ ๋ฆฌ์คํธ๊ฐ ์๋๋ฉด ์ด ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉ์ด ๋ถ๊ฐ๋ฅํ๋ค.
์ด์งํ์ ์๊ณ ๋ฆฌ์ฆ์ด ๋ฌด์์ธ์ง๋, ๋ค๋ฅธ ์๋ฃ๋ค์ ํตํด ์ด๋ฏธ ์ถฉ๋ถํ ๋ง์ด ์ค๋ช ๋์ด ์์ผ๋ฏ๋ก ์ค๋ช ์ ์๋ตํ๋ค.
์ฌ์ฉํ ์ธ์ด๋ python์ด๊ณ ์ฌ๊ท๋ฅผ ์ฌ์ฉํ ๋ฐฉ๋ฒ, if-else๋ฌธ์ ์ฌ์ฉํ ๋ฐฉ๋ฒ ๋ ๊ฐ์ง๋ฅผ ๋ชจ๋ ์ดํด๋ณด์.
๋ฌธ์ ๋ ์ฐพ๊ณ ์ ํ๋ ์์ element๊ฐ ๋ฆฌ์คํธ ์์ ์กด์ฌํ๋ฉด ๊ทธ ์์์ ์ธ๋ฑ์ค๋ฅผ ๋ฆฌํดํ๊ณ , ์์ผ๋ฉด None์ ๋ฆฌํดํ๋ ๊ฒ์ด๋ค.
1. ์ฌ๊ท
def binary_search(element, lst):
mid = len(lst)//2
if not len(lst):
return None
elif element == lst[mid]:
return mid
elif element < lst[mid]:
return binary_search(element, lst[:mid])
else:
return mid+binary_search(element, lst[mid:])
# ํ
์คํธ ์ฝ๋
print(binary_search(2, [2, 3, 5, 6, 7, 10, 11, 13]))
print(binary_search(0, [2, 3, 5, 6, 7, 10, 11, 13]))
print(binary_search(5, [2, 3, 5, 6, 7, 10, 11, 13]))
print(binary_search(3, [2, 3, 5, 6, 7, 10, 11, 13]))
print(binary_search(11, [2, 3, 5, 6, 7, 10, 11, 13]))
Recursion์ ์ด์ฉํ ๋ฌธ์ ๋ฅผ ํ ๋๋ base case๋ฅผ ๊ฐ์ฅ ๋จผ์ ์๊ฐํด์ผ ํ๋ค.
๊ทธ๊ฑธ ์๊ฐํ๊ธฐ ์ด๋ ต๋ค๋ฉด ๋จผ์ , recursive case๋ฅผ ์๊ฐํ๋ค.
์ด๊ฒ ๋ญ๋๋ฉด, ๊ฐ์ ํํ์ด์ง๋ง ๋ ์์ ํฌ๊ธฐ์ ์ํฉ์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋๋ค.
ํ์์ ์ํฉ์ด ๋ฐ๋ณต๋๋ค๊ฐ ๋ ์์์ง ์ ์๋ ๋จ์์ ์ํฉ์ด ์ค๋ฉด ๊ทธ๊ฒ ์ ์์ธ base case์ธ ๊ฒ์ด๋ค.
๊ทธ๋ฆฌ๊ณ ์ด๋ฐ ๋ฐ๋ณต์ ์ธ ๋ถ๋ถ์ ์ ์ธํ ํ์ถ์กฐ๊ฑด์ ๋ฐ๋ก ์ ์ด์ค์ผ ํ ๋๋ ์๋ค.
ํฌ๊ฒ ๋ณด๋ฉด ์ด๊ฒ ์ ๋ถ์ด๊ณ , ๋ฌธ์ ๋ฅผ ์ฌ๋ฌ ๋ฒ ํ์ด์ ์ ์ํด๋ณด์. ์ฐ์ตใฑใฑ!!
์ด ๋ฌธ์ ์์๋
์ฐพ์ผ๋ ค๋ ์ซ์๊ฐ ๋ฆฌ์คํธ์ ์๋ ๊ฒฝ์ฐ์ ์ฐพ์ผ๋ ค๋ ์ซ์๋ฅผ ์ฐพ์์ ๋ ๋ฉ์ถฐ์ผ ํ๋ค.
๊ทธ๋ฌ๊ธฐ ์ํ ๋ถ๋ถ์ด ์์ if not len(lst):, elif element == lst[mid]: ์ด ๋ถ๋ถ๋ค์ด๋ค.
์ ์ฝ๋์์ mid๋ ๊ฐ์ด๋ฐ ์ธ๋ฑ์ค๋ฅผ ๋ํ๋ด๋๋ฐ, ๋ฆฌ์คํธ์ ์ ์ ๋ฐ ๋๋ ๋ค ์ ๋ฐ์ผ๋ก ์ค์ฌ ๊ฐ๋ฉด์ ํ์ํด์ผํ๋ฏ๋ก ๊ทธ์ ๋ง๊ฒ ๋ฆฌ์คํธ slicing์ ์ฌ์ฉํ๋ ค case๋ถ๋ฅ๋ฅผ ํด์คฌ๋ค.
์ฃผ์ํ ์ ์, ๋ฆฌ์คํธ์ ์๋ถ๋ถ์ ์ฌํ์ํ ๋๋ ๊ด์ฐฎ์ง๋ง ๋ฆฌ์คํธ์ ๋ค ์ ๋ฐ ๋ถ๋ถ์ ์ฌํ์ํ ๋๋, ์๋ก ํธ์ถ๋ ํจ์์ ์ธ์๋ก ๋ค์ด์จ ๋ฆฌ์คํธ์์ ํ์ํ๋ ๊ฑฐ๋๊น ์ธ๋ฑ์ค๊ฐ ๋ค์ 0๋ถํฐ ์์ํ๋ค๋ ๊ฒ์ด๋ค.
๊ทธ๋ ์ง๋ง ๋๋ ์๋ ๋ฆฌ์คํธ์์์ ์์์ ์ธ๋ฑ์ค๋ฅผ ๋ฐํ๋ฐ๊ธธ ์ํ๋ฏ๋ก, return์ ํ ๋ mid๋ฅผ ๋ํด์ค๋ค.
์ถ๊ฐ ์ค๋ช ์ ๋ง๋ถ์ด์๋ฉด) ์๋ก ํธ์ถ๋ ํจ์์ ์ธ์ ์ค ๋ฆฌ์คํธ์์ ์ธ๋ฑ์ค๊ฐ 0์ธ ์์๋ ๋ฐ๋ก ์ด์ ์ ํธ์ถ๋์์ ๋๋ ์ธ๋ฑ์ค๊ฐ mid์์ ๊ฒ์ด๋ค. ๋ฐ๋ผ์ ์๋ก ํธ์ถ๋ ๋ฆฌ์คํธ์์ ์ฐพ์ ์์์ ์ธ๋ฑ์ค์ mid๋ฅผ ๋ํด์ฃผ๋ฉด ์ด์ ์ ํธ์ถ๋ ์ธ๋ฑ์ค๋ฅผ ๋ฐ์ํ ์ ์๊ฒ ๋๋ค.
2. if-else
def binary_search(element, lst):
start_idx = 0
end_idx = len(lst) - 1
while start_idx <= end_idx:
mid = (start_idx + end_idx) // 2
if lst[mid] == element:
return mid
elif lst[mid] > element:
end_idx = mid - 1
else:
start_idx = mid + 1
return None
# ํ
์คํธ ์ฝ๋
print(binary_search(2, [2, 3, 5, 6, 7, 10, 11, 13]))
print(binary_search(0, [2, 3, 5, 6, 7, 10, 11, 13]))
print(binary_search(5, [2, 3, 5, 6, 7, 10, 11, 13]))
print(binary_search(3, [2, 3, 5, 6, 7, 10, 11, 13]))
print(binary_search(11, [2, 3, 5, 6, 7, 10, 11, 13]))
์ด์ง ํ์์ ํ์ ๋ฒ์๋ฅผ ๋ฐ์ผ๋ก ์ค์ฌ๋๊ฐ์ผ ํ๋ฏ๋ก, ํ์ํ๋ ๋ฒ์์ ์์, ๋ ์ธ๋ฑ์ค๋ฅผ ๋ํ๋ด๋ ๋ณ์๋ฅผ ์์ฑํ๋ค.
while๋ฐ๋ณต๋ฌธ์ ํตํด ๋ฆฌ์คํธ ์์ ์ฐพ๊ณ ์ ํ๋ ์์๊ฐ ์๋ค๋ฉด ํด๋น ์์์ ์ธ๋ฑ์ค๋ฅผ ๋ฆฌํดํ๊ณ , ์์ผ๋ฉด ๋ฐ๋ณต๋ฌธ ํ์ถ ํ None์ ๋ฆฌํดํ๋ค.
์ฌ๊ธฐ์์๋ ๋ฐ๋ณตํด์ผํ ๊ฒ์
ํ์ฌ ํ์๋ฒ์์์ ์ค๊ฐ๊ฐlst[mid]๊ฐ ์ฐพ๊ณ ์ ํ๋ ์์๋ผ๋ฉด->mid ๋ฆฌํด ๋์ด๊ณ ,
์๋๋ผ๋ฉด ํ์ ๋ฒ์๋ฅผ ์ค์ฌ์ผ ํ๋ค.
ํ์ ๋ฒ์๋ฅผ ์ค์ด๊ธฐ ์ํด์๋, ์ ๋ต์์์ ์ค๊ฐ๊ฐ์ ๋น๊ตํด์
์ค๊ฐ๊ฐ์ด ๋ ํฌ๋ค๋ฉด ๋ฆฌ์คํธ์ ์์ ๋ฐ๋ถ๋ถ์ ๋ด์ผ ํ๊ณ
์ค๊ฐ๊ฐ์ด ๋ ์๋ค๋ฉด ๋ฆฌ์คํธ์ ๋ท์ ๋ฐ๋ถ๋ถ์ ๋ด์ผ ํ๋ค.
๋ฐ๋ผ์ ์ด๋ฅผ ์ฝ๋๋ก ์์ฑํ๋ฉด ์์ ๊ฐ๋ค.
์ด ๋ฐ๋ณต๋ฌธ์ ๋๊น์ง ์ฐพ์๋ดค์๋ ์์ผ๋ฉด ํ์ถํ๋ค.
์ฌ๊ธฐ์ ๊ณ์ ๋ณํ์ฃผ๋๋ถ๋ถ์ ์ฒซ,๋์ธ๋ฑ์ค์ธ๋ฐ, ์ด๋ฅผ ์กฐ์ํ๋ฉด์ ๊ณ์ ๋ฒ์๋ฅผ ์ค์ฌ๋๊ฐ๋ค ๋ณด๋ฉด ๋ ์ธ๋ฑ์ค๊ฐ ์๊ฐ๋ฆฌ๊ฒ ๋ ๊ฒ์ด๋ค. ๊ทธ๋ฌ๋ฏ๋ก ํ์ถ์กฐ๊ฑด์ ์์ ๊ฐ์ด ์จ์ค๋ค.
'๐ป Computer Science > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ (0) | 2024.11.02 |
---|---|
Arrays.sort(๋ฐฐ์ด, ๋น๊ต ๊ธฐ์ค) (2) | 2024.10.03 |