Coding Test/Codility

6. ์ •๋ ฌ (Sorting) Codility Lesson ํ•œ๊ตญ์–ด ์ •๋ฆฌ๋ณธ (JavaScript ver.)

chamroro 2025. 3. 1. 23:29

์ •๋ ฌ(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) (์ •๋ ฌ ํ›„ ํ•œ ๋ฒˆ ์ˆœํšŒ)

๋ฐ˜์‘ํ˜•