๐ก์ ๋ ฌ์ด๋?
์ ๋ ฌ์ด๋ ๋ฐ์ดํฐ๋ฅผ ํน์ ํ ๊ธฐ์ค์ ๋ฐ๋ผ ์์๋๋ก ๋์ด ํ๋๊ฒ ์ด๋ค. ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ์ด๋ณธ ์ฌ๋์ด๋ผ๋ฉด ์ ๋ ฌ์ ๋ํด ์๋ ์์ด ๋ง์ด ๋ค์ด๋ดค์ํ ๋ฐ, ์ค๋์ ์ด ์ ๋ ฌ์ ๋ํด์ ์ง๊ณ ๋์ด๊ฐ ๋ณด์. ์ํฉ์ ์ ์ ํ์ง ๋ชปํ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ฉด ํ์ ์ด์์ผ๋ก ์๊ฐ์ ๋ง์ด ์์ํ๊ฒ ๋๋๋ฐ, ์ด๊ฒ ๋๋ฌธ์ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ๊ณต๋ถํ๋ ์ด์ ์ด๊ธฐ๋ ํ๋ค. ๋ค์์ ์ฌ๋ฌ๊ฐ์ง ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ๋ํ ์ค๋ช ์ด๋ค. ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ ๊ธฐ๋ณธ์ผ๋ก ํ์ด์ฌ์์ ์ ๊ณต๋๋ ์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ด์ฉํด ์ค๋ฆ์ฐจ์ ์ ๋ฆฌ๋ฅผ ํ ํ, ๋ฌธ์์ด์ ๋ค์ง๋ ๋ฉ์๋๋ฅผ ํ์ฉํ์ฌ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ ํ ์ ์๋ค. ์ด ๋ค์ง๋ ์ฐ์ฐ์ O(N)์ด๊ธฐ ๋๋ฌธ์, ์ฌ๊ธฐ์๋ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ๋ง ๋ค๋ฃจ๋๋ก ํ๊ฒ ๋ค.
๐ ์ ํ ์ ๋ ฌ(Selection Sort)
์ปดํจํฐ๊ฐ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ ๋ ์ด๋ป๊ฒ ํ ์ง ์๊ฐํด๋ณด์. ์ด ๋ฐ์ดํฐ ์ค์์ ๊ฐ์ฅ ์์ ๋ฐ์ดํฐ๋ฅผ ์ ํํด ๋งจ ์์ ์๋ ๋ฐ์ดํฐ์ ๋ฐ๊พธ๊ณ , ๊ทธ ๋ค์ ์์ ๋ฐ์ดํฐ๋ฅผ ์ ํํด ์์์ ๋๋ฒ์งธ ๋ฐ์ดํฐ์ ๋ฐ๊พธ๋ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ฉด ์ด๋จ๊น? ์ด ๋ฐฉ๋ฒ์ ๊ฐ์ฅ ์์์ ์ธ ์ ๋ ฌ ๋ฐฉ๋ฒ์ผ๋ก, ์ ํ ์ ๋ ฌ(selection sort)๋ผ๊ณ ๋ถ๋ฅธ๋ค. ์ดํด๋ฅผ ๋๊ธฐ ์ํด ์์์ ํจ๊ป ๋ณด์.
์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์์๋ ์ ๋ ฌํ ๋ฐ์ดํฐ์ ๊ฐฏ์๋ฅผ N์ผ๋ก ์นญํ๋ค. ๋ค์ ์์ ์์๋ N = 10์ธ ๊ฒฝ์ฐ๋ฅผ ๊ฐ์ ํ๋ค. ๋ํ, ๋ค์ ๊ทธ๋ฆผ์์ ํ์ ์นด๋๋ 'ํ์ฌ ์ ๋ ฌ๋์ง ์์ ๋ฐ์ดํฐ์ค ์ต์๊ฐ'์ ์๋ฏธํ๋ฉฐ, ํ๋์ ์นด๋๋ '์ด๋ฏธ ์ ๋ ฌ๋' ๋ฐ์ดํฐ๋ฅผ ์๋ฏธํ๋ค.
๋ค์์ ํ์ด์ฌ์ผ๋ก ๊ตฌํํ ์ ํ์ ๋ ฌ ์ฝ๋์ด๋ค.
array = [7, 5, 9, 0, 3, 1, 6, 2, 4, 8]
for i in range(len(array)):
min_index = i # ๊ฐ์ฅ ์์ ์์์ ์ธ๋ฑ์ค
for j in range(i + 1, len(array)):
if array[min_index] > array[j]:
min_index = j
array[i], array[min_index] = array[min_index], array[i] # ์ค์ํ
print(array)
์ฌ๊ธฐ์ ์ค์ํ(swap)๋ ํน์ ํ ๋ฆฌ์คํธ๊ฐ ์ฃผ์ด์ก์๋ ๋ ๋ณ์์ ์์น๋ฅผ ๋ณ๊ฒฝํ๋ ์์ ์ ์๋ฏธํ๋ค. ํ์ด์ฌ์์๋ ๊ฐ๋จํ ๋ฆฌ์คํธ ๋ด์ ๋ ์์์ ์์น๋ฅผ ๋ณ๊ฒฝ ํ ์ ์๋ค.
# 0 ์ธ๋ฑ์ค์ 1 ์ธ๋ฑ์ค์ ์์ ๊ต์ฒดํ๊ธฐ
array = [3, 5]
array[0], array[1] = array[1], array[0]
print(array)
๐ ์ ํ ์ ๋ ฌ์ ์๊ฐ ๋ณต์ก๋
๊ทธ๋ ๋ค๋ฉด, ์ ํ ์ ๋ ฌ์ ์๊ฐ ๋ณต์ก๋๋ ์ด๋จ๊น? ์ฌ์ค ์์์ ์ธ๊ธํ ๊ฐ์ฅ ์์ ๋ฐ์ดํฐ๋ฅผ ์ ํํด ๋งจ ์์ ์๋ ๋ฐ์ดํฐ์ ๋ฐ๊พธ๊ณ , ๊ทธ ๋ค์ ์์ ๋ฐ์ดํฐ๋ฅผ ์ ํํด ์์์ ๋๋ฒ์งธ ๋ฐ์ดํฐ์ ๋ฐ๊พธ๋ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ฉด ์ด๋จ๊น? ์ฌ๊ธฐ์ ์๊ณ ๋ฆฌ์ฆ์ ๊ณต๋ถ ํด ๋ณธ์ฌ๋์ด๋ผ๋ฉด ๋์น๋ฅผ ์ฑ ์ ์๋ฏ, ๋๋ฌด ์ฐ์ฐ์ ํ์๊ฐ ๋ง๋ค. ์ด์ ๋ ๋งค ๋ฐ๋ณต๋ฌธ๋ง๋ค ๋ฆฌ์คํธ๋ฅผ ์ฐจ๋ก๋ก ๊ฒ์ฌํ๋ฉฐ ๊ฐ์ฅ ์์ ๊ฐ์ ์ฐพ์์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค.
์ ํ ์ ๋ ฌ์ N -1 ๋ฒ๋งํผ ๊ฐ์ฅ ์์ ์๋ฅผ ์ฐพ์์ ๋งจ ์์ผ๋ก ๋ณด๋ด์ผ ํ๋ค. ๋ํ ๋งค๋ฒ ๊ฐ์ฅ ์์ ์๋ฅผ ์ฐพ๊ธฐ ์ํด์ ๋น๊ต ์ฐ์ฐ์ด ํ์ํ๋ค. ์ ํ ์ ๋ ฌ์ ์๊ฐ ๋ณต์ก๋๋ O(N^2)๋ก, ํจ์จ์ด ์ข์ง ์์ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ์ง๊ด์ ์ผ๋ก ์ดํดํ์๋ฉด, ์์ค์ฝ๋์์ for๋ฐ๋ณต๋ฌธ์ด 2์ค์ผ๋ก ๊ฒน์ณ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๋ง์ฝ, ์ ๋ ฌํด์ผ ํ ๋ฐ์ดํฐ์ ๊ฐฏ์๊ฐ 100๋ฐฐ๋ก ๋์ด๋๋ฉด, ์ด๋ก ์ ์ผ๋ก ์ํ์๊ฐ์ 10,000๋ฐฐ๊ฐ ๋์ด๋๋ค. ๊ทธ๋ ๋ค๋ฉด, ์ด๋ฌํ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ ์ ํ ์ ๋ ฌ์ด ์ผ๋ง๋ ํจ์จ์ ์ผ๊น?
์์ ํ์์ ๋ณผ ์ ์๋ฏ, ์ ํ ์ ๋ ฌ์ ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ ์๋๋ค. ํ์ง๋ง ์ฝ๋ฉ ํ ์คํธ์์ ๊ฐ์ฅ ์์ ๊ฐ์ ์ฐพ๋ ์ผ์ด ์ฆ์ผ๋ฏ๋ก ํญ์ ๊ธฐ์ตํด๋์.
๐ ์ฝ์ ์ ๋ ฌ(Selection Sort)
๋นํจ์จ์ ์ธ ์ ํ ์ ๋ ฌ ๋์ ๋ค๋ฅธ ์๊ณ ๋ฆฌ์ฆ์ ์์๊น? "๋ฐ์ดํฐ๋ฅผ ํ๋์ฉ ํ์ธํ๋ฉฐ, ๊ฐ ๋ฐ์ดํฐ๋ฅผ ์ ์ ํ ์์น์ ์ฝ์ ํ๋ฉด ์ด๋จ๊น?" ์ฝ์ ์ ๋ ฌ์ ์ ํ ์ ๋ ฌ์ ๋นํด ๊ตฌํ ๋์ด๋๊ฐ ๋์ ํธ์ด์ง๋ง ์ ํ ์ ๋ ฌ์ ๋นํด ์คํ ์๊ฐ ์ธก๋ฉด์์ ๋ ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์ ์๋ ค์ ธ ์๋ค. ํนํ ์ฝ์ ์ ๋ ฌ์ ํ์ํ ๋๋ง ์์น๋ฅผ ๋ฐ๊พธ๋ฏ๋ก '๋ฐ์ดํฐ๊ฐ ๊ฑฐ์ ์ ๋ ฌ๋์ด ์์๋' ํจ์จ์ ์ด๋ค. ์ ํ ์ ๋ ฌ์ ํ์ฌ ๋ฐ์ดํฐ์ ์ํ์ ์๊ด์์ด ๋ฌด์กฐ๊ฑด ๋ชจ๋ ์์๋ฅผ ๋น๊ตํ๊ณ ์์น๋ฅผ ๋ฐ๊พธ๋ ๋ฐ๋ฉด, ์ฝ์ ์ ๋ ฌ์ ๊ทธ๋ ์ง ์๋ค.
์ฝ์ ์ ๋ ฌ์ ํน์ ํ ์์น์ ๋ฐ์ดํฐ๋ฅผ '์ฝ์ 'ํ๋ค๋ ์๋ฏธ์์ ์ฝ์ ์ ๋ ฌ ์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค. ๋๋ถ์ด ์ฝ์ ์ ๋ ฌ์ ํน์ ๋ฐ์ดํฐ๊ฐ ์ฝ์ ๋๊ธฐ ์ ์ ๊ทธ ์๊น์ง์ ๋ฐ์ดํฐ๋ ์ด๋ฏธ ์ ๋ ฌ ๋์ด์๋ค๊ณ ๊ฐ์ ํ๋ค. ๋ค์๊ณผ ๊ฐ์ด ์ด๊ธฐ ๋ฐ์ดํฐ๊ฐ ๊ตฌ์ฑ๋์ด ์๋ค๊ณ ๊ฐ์ ํด๋ณด์. ์ฝ์ ์ ๋ ฌ์ ๋๋ฒ์งธ ๋ฐ์ดํฐ๋ถํฐ ์์ํ๋ค. ์๋ํ๋ฉด ์ฒซ๋ฒ์งธ ๋ฐ์ดํฐ๋ ๊ทธ ์์ฒด๋ก ์ ๋ ฌ ๋์ด ์๋ค๊ณ ํ๋จํ๊ธฐ ๋๋ฌธ์ด๋ค.
array = [7, 5, 9, 0, 3, 1, 6, 2, 4, 8]
for i in range(1, len(array)):
for j in range(i, 0, -1): # ์ธ๋ฑ์ค i๋ถํฐ 1๊น์ง ๊ฐ์ํ๋ฉฐ ๋ฐ๋ณตํ๋ ๋ฌธ๋ฒ
if array[j] < array[j - 1]: # ํ ์นธ์ฉ ์ผ์ชฝ์ผ๋ก ์ด๋
array[j], array[j - 1] = array[j - 1], array[j]
else: # ์๊ธฐ๋ณด๋ค ์์ ๋ฐ์ดํฐ๋ฅผ ๋ง๋๋ฉด ๊ทธ ์์น์์ ๋ฉ์ถค
break
print(array)
์ฌ๊ธฐ์ range์ ๋ํด ์ ๊น ์ง๊ณ ๋์ด๊ฐ ๋ถ๋ถ์ด ์๋๋ฐ,
ํ์ด์ฌ์ `range`๋ 3๊ฐ์ ๋งค๊ฐ ๋ณ์(`start`, `end`, `step`)๋ฅผ ๋ฐ๋๋ค. ์ธ ๋ฒ์งธ ๋งค๊ฐ ๋ณ์์ธ `step`์ ์ซ์ ๊ฐ์ ๊ฐ๊ฒฉ์ ์ง์ ํ๋ ์ญํ ์ ํ๋ค. ์ด `step` ๊ฐ์ด ์์์ผ ๊ฒฝ์ฐ `start` ์ธ๋ฑ์ค๋ถํฐ `end-1` ์ธ๋ฑ์ค๊น์ง `step`๋งํผ ์ฆ๊ฐํ๋ฉฐ ์ํํ๋ค. ๋ฐ๋ฉด, `step` ๊ฐ์ด -1์ผ ๊ฒฝ์ฐ `start` ์ธ๋ฑ์ค๋ถํฐ `end+1` ์ธ๋ฑ์ค๊น์ง 1์ฉ ๊ฐ์ํ๋ค. ์ด๋ฅผ ์ด์ฉํ๋ฉด ๋ฆฌ์คํธ๋ฅผ ์ญ์์ผ๋ก ์ํํ๊ฑฐ๋ ํน์ ๋ฒ์์์ ๊ฐ์ํ๋ ์์๋ก ๊ฐ์ ์์ฑํ ์ ์๋ค.
์๋ฅผ ๋ค์ด, `range(5, 0, -1)`์ 5๋ถํฐ ์์ํ์ฌ 1์ฉ ๊ฐ์ํ๋ฉด์ 1๊น์ง์ ์ซ์๋ฅผ ์์ฑํ๋ค.
for i in range(5, 0, -1):
print(i, end=' ') # ์ถ๋ ฅ: 5 4 3 2 1
์ด ์ฝ๋๋ `start`๊ฐ 5, `end`๊ฐ 0, `step`์ด -1์ด๋ฏ๋ก, 5์์ 1์ฉ ๊ฐ์ํ๋ฉฐ 1๊น์ง์ ์ซ์๋ฅผ ์ถ๋ ฅํ๋ค. ์ด์ ๊ฐ์ด `range` ํจ์์ `step` ๋งค๊ฐ ๋ณ์๋ฅผ ์ ์ ํ ์ฌ์ฉํ๋ฉด ๋ค์ํ ์ํ ํจํด์ ๊ตฌํํ ์ ์๋ค.
์ฝ์ ์ ๋ ฌ์ ์๊ฐ ๋ณต์ก๋๋ ์ ํ ์ ๋ ฌ๊ณผ ๊ฐ์ด O(N^2)์ด๋ค. ํ์ง๋ง, ์ฌ๊ธฐ์ ๊ผญ ๊ธฐ์ต ํด์ผํ ๋ด์ฉ์ ์ฝ์ ์ ๋ ฌ์ ํ์ฌ ๋ฐ์ดํฐ๊ฐ ์ ๋ ฌ๋ ์ํ๋ผ๋ฉด ๋งค์ฐ ๋น ๋ฅด๊ฒ ๋์ ํ๋ค๋ ์ ์ด๋ค. ๊ฐ์ฅ ํจ์จ์ ์ธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์๋ ค์ง ํต ์ ๋ ฌ ์กฐ์ฐจ๋ ์ ๋ ฌ์ด ๊ฑฐ์ ๋์ด์๋ ์ํฉ์์๋ ์ฝ์ ์ ๋ ฌ์ด ๋ ๋น ๋ฅด๊ฒ ๋์ํ๋ค.
๋ค์์๋ ํต ์ ๋ ฌ์ ๋ํด์ ์ค๋ช ํ๊ฒ ๋ค.
'์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Algorithm]์ด์ง ํ์ (0) | 2024.07.12 |
---|---|
[Algorithm]์ ๋ ฌ(2) - ํต ์ ๋ ฌ, ๊ณ์ ์ ๋ ฌ (0) | 2024.07.09 |
[Algorithm]DFS/BFS(3) - BFS (0) | 2024.07.02 |
[Algorithm] DFS/BFS(2) - DFS (0) | 2024.07.02 |
[Algorithm] DFS/BFS(1) - DFS/BFS๋ฅผ ์ดํดํ๊ธฐ ์ํ ์๋ฃ๊ตฌ์กฐ (0) | 2024.06.29 |