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

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

    ๋ฐ˜์‘ํ˜•

    ๋Œ“๊ธ€