์ ๋ ฌ(Sorting)์ด๋?
์ ๋ ฌ์ด๋ ๋ฐ์ดํฐ๋ฅผ ํน์ ํ ์์๋๋ก ๋ฐฐ์นํ๋ ๊ณผ์ ์ด๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ซ์ ๋๋ ๋ฌธ์์ด์ ๊ฐ์ ๋ฐ๋ผ ์ ๋ ฌํ๋ค. ์๋ฅผ ๋ค์ด, ํ์์ ํค ์์๋๋ก ์ ๋ ฌํ๊ฑฐ๋, ๋์๋ฅผ ์ธ๊ตฌ์ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ ์ ์๋ค.
๋ค์๊ณผ ๊ฐ์ ๋ฐฐ์ด์ด ์๋ค๊ณ ๊ฐ์ ํ์.
A = [5, 2, 8, 14, 1, 16];
์ด๋ฅผ ์ซ์ ํฌ๊ธฐ ์์๋ก ์ ๋ ฌํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
A = [1, 2, 5, 8, 14, 16];
์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐ ๋ณต์ก๋์ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ๋ฐ๋ผ ์ฐจ์ด๊ฐ ์๋ค. ์ฌ๊ธฐ์๋ ๋ํ์ ์ธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ดํด๋ณธ๋ค.
1. ์ ํ ์ ๋ ฌ (Selection Sort)
์์ด๋์ด: ๋ฐฐ์ด์์ ๊ฐ์ฅ ์์ ์์๋ฅผ ์ฐพ์ ์ฒซ ๋ฒ์งธ ์์น์ ๊ตํํ๋ ์์ ์ ๋ฐ๋ณตํ๋ค.
JavaScript ์ฝ๋:
function selectionSort(A) {
let n = A.length;
for (let k = 0; k < n; k++) {
let minIndex = k;
for (let j = k + 1; j < n; j++) {
if (A[j] < A[minIndex]) {
minIndex = j;
}
}
[A[k], A[minIndex]] = [A[minIndex], A[k]]; // swap
}
return A;
}
์๊ฐ ๋ณต์ก๋: O(n²) (์ด์ค ๋ฐ๋ณต๋ฌธ ์ฌ์ฉ)
2. ์นด์ดํ ์ ๋ ฌ (Counting Sort)
์์ด๋์ด: ์์์ ๋ฑ์ฅ ํ์๋ฅผ ๋ฐฐ์ด์ ์ ์ฅํ ํ, ์นด์ดํธ ๋ฐฐ์ด์ ๊ธฐ๋ฐ์ผ๋ก ์ ๋ ฌํ๋ค.
JavaScript ์ฝ๋:
function countingSort(A, k) {
let n = A.length;
let count = new Array(k + 1).fill(0);
for (let i = 0; i < n; i++) {
count[A[i]] += 1;
}
let p = 0;
for (let i = 0; i <= k; i++) {
for (let j = 0; j < count[i]; j++) {
A[p++] = i;
}
}
return A;
}
์๊ฐ ๋ณต์ก๋: O(n + k) (๋จ, k ๊ฐ์ด ํด ๊ฒฝ์ฐ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ด ๋ง์์ง ์ ์์)
3. ํฉ๋ณ ์ ๋ ฌ (Merge Sort)
์์ด๋์ด: ๋ฐฐ์ด์ ์ ๋ฐ์ฉ ๋๋ ํ, ๊ฐ๊ฐ ์ ๋ ฌํ๊ณ ๋ณํฉํ๋ ๋ฐฉ์์ด๋ค.
JavaScript ์ฝ๋:
function mergeSort(A) {
if (A.length <= 1) return A;
let mid = Math.floor(A.length / 2);
let left = mergeSort(A.slice(0, mid));
let right = mergeSort(A.slice(mid));
return merge(left, right);
}
function merge(left, right) {
let result = [];
let i = 0, j = 0;
while (i < left.length && j < right.length) {
if (left[i] < right[j]) {
result.push(left[i++]);
} else {
result.push(right[j++]);
}
}
return result.concat(left.slice(i)).concat(right.slice(j));
}
์๊ฐ ๋ณต์ก๋: O(n log n) (๋ถํ + ๋ณํฉ ๊ณผ์ ์ด ๋ก๊ทธ ๋จ์๋ก ์งํ๋จ)
4. ๋ด์ฅ ์ ๋ ฌ ํจ์ (Built-in Sorting)
JavaScript๋ ๊ธฐ๋ณธ์ ์ผ๋ก O(n log n) ๋ณต์ก๋์ ์ ๋ ฌ ํจ์๋ฅผ ์ ๊ณตํ๋ค.
JavaScript ์ฝ๋:
A.sort((a, b) => a - b);
์ด ๋ฐฉ์์ ์ ๋ ฌ ์๋๊ฐ ๋น ๋ฅด๊ณ ์ฝ๋๊ฐ ๊ฐ๊ฒฐํ๊ธฐ ๋๋ฌธ์ ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ๋ด์ฅ ํจ์๋ฅผ ํ์ฉํ๋ ๊ฒ์ด ์ข๋ค.
5. ๋ฐฐ์ด ๋ด ์๋ก ๋ค๋ฅธ ๊ฐ์ ๊ฐ์ ๊ตฌํ๊ธฐ
๋ฐฐ์ด A์ ์๋ ์๋ก ๋ค๋ฅธ ๊ฐ์ ๊ฐ์ ๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด๋ณด์.
O(n log n) (์ ๋ ฌ ํ ๋น๊ต)
JavaScript ์ฝ๋:
function distinct(A) {
if (A.length === 0) return 0;
A.sort((a, b) => a - b);
let result = 1;
for (let k = 1; k < A.length; k++) {
if (A[k] !== A[k - 1]) {
result++;
}
}
return result;
}
์๊ฐ ๋ณต์ก๋: O(n log n) (์ ๋ ฌ ํ ํ ๋ฒ ์ํ)
๋๊ธ