[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