[Algorithm] ๋ณํฉ์ ๋ ฌ - Merge Sort
Updated:
-
Merge Sort
๋ณํฉ์ ๋ ฌ์ ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ 1์ด ๋ ๋ ๊น์ง ๋ถํ ํ ํ ๋ค์ ํฉ์น๋ฉด์ ์ ๋ ฌํ๋ ๋ฐฉ์์ด๋ค.
๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋๋ผ๊ณ ํ ์ ์๋ค.
-
๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ
๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ์ ๋ง ๊ทธ๋๋ก ์ดํด ํ๋ฉด ๋๋ค.
์ด๋ ํ ๋ฌธ์ ๋ฅผ ์์ฃผ ์๊ฒ ๋ถํ ํด์ ํด๊ฒฐํ๋ฉฐ ํฉ์น๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
์ฌ๊ธฐ์๋ ์ ๋ ฌ ํด์ผ ํ ๋ฐฐ์ด๋ค์ ์์ฃผ ์๊ฒ ๋ถํ ํด์ ์ ๋ ฌํ๋ฉฐ ํฉ์น๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค.
์ ๊ทธ๋ฆผ์ ๋ณธ๋ค๋ฉด ๋์ฑ ์ดํด๊ฐ ์ ๋ ๊ฒ์ด๋ค.
ํ์ง๋ง ์ด๋ก ์ ์ผ๋ก๋ ์ดํด๊ฐ ๊ฐ๋ ์ฝ๋๋ก ์ฎ๊ธฐ๋ ค๊ณ ํ๋ฉด ์๊ฐ๋ณด๋ค ์ด๋ ต๋ค.
์ฌ๊ท๋ฅผ ์๋ฒฝํ ์ดํดํ๊ณ ์์ด์ผ ํ๋๋ฐ ์ฒ์ ์ฝ๋ฉํ ๋ ๊ฝค ์ ๋ฅผ ๋จน์๋ค.
๋ณํฉ์ ๋ ฌ์ ๋ฆฌ์คํธ๋ ๋ฐฐ์ด์ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ด ์๋ค.
์ฌ๊ธฐ์๋ ๋ฐฐ์ด์ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ ์๊ฐํ๋๋ก ํ๊ฒ ๋ค.
#define MAX_SIZE 100000 void mergeSort (int *arr, int left, int mid, int right) { int tmpArr[MAX_SIZE]; int i, j, loc; loc = i = left; j = mid + 1; // ์ผ์ชฝ ๋ฐฐ์ด์ ๋ค ์ฎ๊ธฐ๊ฑฐ๋ // ์ค๋ฅธ์ชฝ ๋ฐฐ์ด์ ๋ค ์ฎ๊ธธ๋๊น์ง ๋ฐ๋ณต while ((i <= mid) && (j <= right)) { if (arr[i] <= arr[j]) { tmpArr[loc++] = arr[i++]; } else { tmpArr[loc++] = arr[j++]; } } // ์ค๋ฅธ์ชฝ ๋ฐฐ์ด์ ๋ค ์ฎ๊ธด ๊ฒฝ์ฐ // ๋๋จธ์ง ์ผ์ชฝ ๋ฐฐ์ด์ ์ ๋ถ ์ฎ๊ธด๋ค if (i <= mid) { while (i <= mid) { tmpArr[loc++] = arr[i++]; } } // ์ผ์ชฝ ๋ฐฐ์ด์ ๋ค ์ฎ๊ธด ๊ฒฝ์ฐ // ๋๋จธ์ง ์ค๋ฅธ์ชฝ ๋ฐฐ์ด์ ์ ๋ถ ์ฎ๊ธด๋ค if (j <= right) { while (j <= right) { tmpArr[loc++] = arr[j++]; } } // ์์ ๋ฐฐ์ด์์ ๋ณธ ๋ฐฐ์ด๋ก ๋ณต์ฌํ๋ค for (i = left; i <= right; i++) { arr[i] = tmpArr[i]; } } void merge (int *arr, int left, int right) { int mid = (left + right) / 2; if (mid < right) { merge(arr, 0, mid); // ์ผ์ชฝ ๋ฐฐ์ด ๋ถํ merge(arr, mid+1, right); // ์ค๋ฅธ์ชฝ ๋ฐฐ์ด ๋ถํ mergeSort(arr, left, mid, right); // ์ผ์ชฝ, ์ค๋ฅธ์ชฝ ๋ฐฐ์ด ์ ๋ ฌ } }
๋ฐฐ์ด์ ์ฌ์ฉํ์ฌ ๋ณํฉ์ ๋ ฌ์ ํ ๋ ์ถ๊ฐ ๋ฐฐ์ด์ด ํ์ํ๋ค.
์ถ๊ฐ ๋ฐฐ์ด์ ์ ๋ ฌ์ ๋ฏธ๋ฆฌ ํด์ค ํ ๋ณธ ๋ฐฐ์ด์ ๋ณต์ฌ๋ฅผ ํด์ฃผ๋ ๊ณผ์ ์ด ํ์ํ๊ธฐ ๋๋ฌธ์ด๋ค.
๋ฐ๋ผ์ ํฌ๊ธฐ๊ฐ ์์ฃผ ํฐ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌ ํ๋ ๊ฒฝ์ฐ์๋ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ ์ฅ๊ณต๊ฐ์ ๋ญ๋น๊ฐ ์๋ค.
-
Leave a comment