์๊ฐ ๋ณํฉ ์ ๋ ฌ(Merge Sort)์ ๋ํ์ ์ธ ๋ถํ ์ ๋ณต(Divede and Conquer) ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋๋ก, ๋ฆฌ์คํธ๋ฅผ ๋ฐ์ผ๋ก ๋๋ ๋ค ๊ฐ๊ฐ์ ์ฌ๊ท์ ์ผ๋ก ์ ๋ ฌํ๊ณ , ์ ๋ ฌ๋ ๋ ๊ฐ์ ๋ฆฌ์คํธ๋ฅผ ํฉ์ณ์ ์ ๋ ฌ๋ ํ๋์ ๋ฆฌ์คํธ๋ฅผ ๋ง๋๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. ์๋ ๊ฐ๋ ๐ก ๋ณํฉ ์ ๋ ฌ์ ์ผ๋ฐ์ ์ผ๋ก ๋ค์๊ณผ ๊ฐ์ ์ธ ๋จ๊ณ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. ๋ถํ (Divide): ์ ๋ ฅ ๋ฆฌ์คํธ๋ฅผ ๊ฐ์ ํฌ๊ธฐ์ ๋ ๊ฐ์ ๋ถ๋ถ ๋ฆฌ์คํธ๋ก ๋ถํ ํฉ๋๋ค. ์ด๋ ๋ถํ ์ ๋ฆฌ์คํธ์ ์ค๊ฐ ์ง์ ์์ ์ํ๋ฉ๋๋ค. ์ ๋ณต(Conquer): ๊ฐ ๋ถ๋ถ ๋ฆฌ์คํธ๋ฅผ ์ฌ๊ท์ ์ผ๋ก ๋ณํฉ์ ๋ ฌ์ ์ด์ฉํด ์ ๋ ฌํฉ๋๋ค. ์ด ๊ณผ์ ์ ์ ๋ ฅ ๋ฆฌ์คํธ์ ํฌ๊ธฐ๊ฐ ์ถฉ๋ถํ ์์์ง ๋๊น์ง ๋ฐ๋ณต๋ฉ๋๋ค. ๋ณํฉ(Merge): ์ ๋ ฌ๋ ๋ ๋ถ๋ถ ๋ฆฌ์คํธ๋ฅผ ํ๋์ ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ก ๋ณํฉํฉ๋๋ค. 0๊ฐ ์์, 1๊ฐ ์์ ๋ฐฐ์ด์ด ..
์๊ฐ ๊ฐ๋จํ๊ณ ์ง๊ด์ ์ธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋์ ๋๋ค. ๋ฐฐ์ด์ ์์๋ฅผ ์์๋๋ก ํ์ํ๋ฉฐ, ๊ฐ ์์๋ฅผ ์ด๋ฏธ ์ ๋ ฌ๋ ๋ฐฐ์ด ๋ถ๋ถ๊ณผ ๋น๊ตํ์ฌ ์ ์ ํ ์์น์ ์ฝ์ ํ๋ ๋ฐฉ์์ผ๋ก ์ ๋ ฌ์ ์งํํฉ๋๋ค. ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ๋ค๋ฅธ ๊ณ ๊ธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ๋ณด๋ค ์ฑ๋ฅ์ด ๋จ์ด์ง๊ธฐ ๋๋ฌธ์ ๋งค์ฐ ํฐ ๋ฐฐ์ด์ด๋ ์๊ฐ์ ํ์ด ์๋ ๊ฒฝ์ฐ์๋ ๋ค๋ฅธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ์์ ์ฝ๋ // ์ฒซ ๋ฒ์งธ ๋ฐฉ๋ฒ function insertionSort(array) { for (let i = 1; i = 0 && array[j] > current) { array[j + 1] = array[j]; j--; } array[j ..
์๊ฐ ์ฃผ์ด์ง ๋ฆฌ์คํธ์์ ๊ฐ์ฅ ์์ ๊ฐ์ ์ ํํ์ฌ ๋งจ ์์ ์์น์ํค๊ณ , ๊ทธ๋ค์์ผ๋ก ์์ ๊ฐ์ ์ฐพ์ ๋ ๋ฒ์งธ ์์น์ ์์น์ํค๋ ๊ณผ์ ์ ๋ฐ๋ณตํ์ฌ ์ ๋ ฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. ์์ผ๋ก ๋ณด๋ด์ง ์์๋ ๋ ์ด์ ์์น๊ฐ ๋ณ๊ฒฝ๋์ง ์์ต๋๋ค. ๊ธฐ๋ณธ ๊ฐ๋ ์ ํ ์ ๋ ฌ์ ๊ฐ๋จํ๋ฉด์๋ ์ดํดํ๊ธฐ ์ฝ๊ณ ์ฝ๋ ๊ตฌํ์ด ์ฌ์ด ์๊ณ ๋ฆฌ์ฆ์ด์ง๋ง, ๊ทธ๋งํผ ์๊ฐ ๋ณต์ก๋๊ฐ ๋์ ๋๊ท๋ชจ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ ๋๋ ์ฑ๋ฅ์ด ๋จ์ด์ง๋ ๋จ์ ์ด ์์ต๋๋ค. ์ ํ ์ ๋ ฌ์ ์๊ฐ ๋ณต์ก๋๋ O(N^2)์ผ๋ก, ์ ๋ ฅ ๋ฐ์ดํฐ์ ํฌ๊ธฐ๊ฐ ์ปค์ง์๋ก ์ฑ๋ฅ ์ ํ๊ฐ ๋์ฑ ์ฌํด์ง๋๋ค. ์์ ์ฝ๋ function selectionSort(arr) { const n = arr.length; for (let i = 0; i < n - 1; i++) { let minIndex = i; for (let..
์๊ฐ ๋ฒ๋ธ ์ ๋ ฌ(Bubble Sort)์ ๊ฐ์ฅ ๊ฐ๋จํ๊ณ ๊ธฐ๋ณธ์ ์ธ ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋๋ก, ์ด๋ฆ์์๋ ์ ์ ์๋ฏ์ด ๋ฐฐ์ด์ ์์๋ฅผ '๊ฑฐํ(Bubble)'์ฒ๋ผ ์๋ก ๊ตํํด ๊ฐ๋ฉฐ ์ ๋ ฌํ๋ ๋ฐฉ์์ ๋๋ค. ์ฆ, ์๋ก ์ธ์ ํ ๋ ์์๋ฅผ ๋น๊ตํด๊ฐ๋ฉฐ ์ค๋ฆ์ฐจ์์ด๋ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ์ ์งํํฉ๋๋ค. ๊ธฐ๋ณธ ๊ฐ๋ ๋ฒ๋ธ ์ ๋ ฌ์ ๊ฐ๋ ์ ๋ง์ฝ ์ซ์ ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ์ํฉ์์ ๋ ํฐ ์ซ์๊ฐ ํ ๋ฒ์ ํ๋์ฉ ๋ค๋ก ์ด๋ํ๋ ๋ฐฉ๋ฒ์ ๋๋ค. ๊ธฐ๋ณธ์ ์ผ๋ก ์ด๋ค ํญ๋ชฉ์ด ๋ ํฌ๋ฉด ๊ตํํ๊ณ , ๋ค์ ํญ๋ชฉ๊ณผ ๋น๊ตํ๊ณ , ๋ค์ ํญ๋ชฉ๋ณด๋ค ๋ ํฌ๋ฉด ๋ ๊ตํ์ ํ๊ณ , ๋ค์ ๋ค์ ํญ๋ชฉ๊ณผ ๋น๊ตํ๋ฉด์ ๋ฐ๋ณต์ ํฉ๋๋ค. ์ค๋ฆ์ฐจ์์ ์ํฉ์์๋ ๊ฐ์ฅ ํฐ ๊ฐ์ด ์๋จ์ ํฅํด์ ๊ฐ์ ์ ๋ ฌํ๋ ๋ฐฉ์์ผ๋ก ๋ชฉ๋ก์ ๋ง๋ญ๋๋ค. ์์ ์ฝ๋ #1 function bubbleSort(arr)..
๐ ๋ค์ด๊ฐ๋ฉฐ ์๊ณ ๋ฆฌ์ฆ, ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ณต๋ถํ๋ ๋ฐ์ ์์ด์ ์๊พธ ๋น ์ค(Big O), ๋น ์ค(Big O) ๊ฑฐ๋ฆฌ๋๋ฐ ๋๋์ฒด ๋น ์ค(Big O)๊ฐ ๋ญ๊ณ ์ ์ฌ์ฉํ๋ ๊ฑด์ง ๋ชฐ๋ผ์ ๊ณต๋ถํ ๋ด์ฉ์ ์ ๋ฆฌํ๊ฒ ๋๋ค. 1. ๋น ์ค(Big O) ํ๊ธฐ๋ฒ์ ์ ์ฌ์ฉํ๋ ๊ฑฐ์ง? ๋จผ์ ๋น ์ค(Big O) ํ๊ธฐ๋ฒ์ ์ ์ฌ์ฉํ๋ ๊ฑธ๊น. ์๋ฃ๊ตฌ์กฐ, ์๊ณ ๋ฆฌ์ฆ ํด๊ฒฐ์ ์์ด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ ๋ฐฉ๋ฒ์ด ์ฌ๋ฌ ๊ฐ์ง์ธ ๊ฒฝ์ฐ๊ฐ ๋๋ค์์ด๋ค. ์ ์ n์ ๋ฐ์ผ๋ฉด 1๋ถํฐ n๊น์ง์ ํฉ์ ๊ตฌํ๋ ๋ ๊ฐ์ง์ ์ฝ๋๋ฅผ ์๋ก ๋ค์ด๋ณด๊ฒ ๋ค. ์ฒซ ๋ฒ์งธ ์ฝ๋ function addUpTo(n) { let total = 0; for (let i = 1; i O(1), O(5n^2) => O(n^2) ๋ฑ ์ด๋ฐ ์์ผ๋ก ํ๊ธฐํ๋ ๊ฒ์ด๋ค. 3-3 ๊ณ์ฐ ๋ฐฉ๋ฒ ๊ฐ๋จํ๊ฒ ๋งํ๋ฉด ์ฐ์ฐ์ด ๋ช ..