๊ธ€ ์ž‘์„ฑ์ž: ๊ฐœ๋ฐœํ•˜๋Š” ํ›ˆ์ด

ํ•ฉ๋ณ‘์ •๋ ฌ, ๋จธ์ง€์†ŒํŠธ, ๋ณ‘ํ•ฉ์ •๋ ฌ

ํ•ฉ๋ณ‘์ •๋ ฌ์€ ํ€ต์ •๋ ฌ๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ๋ถ„ํ• ์ •๋ณต์„ ์ด์šฉํ•ด์„œ ์ •๋ ฌ์„ ์ˆ˜ํ–‰ํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด๋‹ค. ํ€ต์ •๋ ฌ๊ณผ๋Š” ๋‹ค๋ฅด๊ฒŒ ํ•ญ์ƒ ๐›ฉ(nlgn) ์˜ ์‹œ๊ฐ„ ๋ณต์žก๋„๋ฅผ ๋ณด์žฅํ•œ๋‹ค๋Š” ์žฅ์ ์ด ์žˆ์ง€๋งŒ, ์ •๋ ฌ์„ ์œ„ํ•ด ์ถ”๊ฐ€์ ์ธ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ํฌ๊ฒŒ ์‚ฌ์šฉํ•œ๋‹ค๋Š” ๋‹จ์ ์ด ์žˆ๋‹ค.

Algorithm Concept

ํ•ฉ๋ณ‘์ •๋ ฌ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์€ ๊ณผ์ •์„ ํ†ตํ•ด ๋ฐฐ์—ด์˜ ์š”์†Œ๋“ค์„ ์ •๋ ฌํ•˜๊ฒŒ ๋œ๋‹ค. (์˜ค๋ฆ„์ฐจ์ˆœ)

  1. ๋‚˜๋ˆ„์–ด์ง„ ๋ฐฐ์—ด์˜ ๊ธธ์ด๊ฐ€ 1์ด ๋ ๋•Œ๊นŒ์ง€ ๋ฐฐ์—ด์„ ๋ฐ˜์œผ๋กœ ๊ณ„์† ๋‚˜๋ˆˆ๋‹ค.
  2. ๋‚˜๋ˆ„์–ด์ง„ ๋ฐฐ์—ด์„ ํ•ฉ์น˜๋ฉด์„œ ์ •๋ ฌ์„ ์ˆ˜ํ–‰ํ•˜๋ฉด์„œ ํ•ฉ์นœ๋‹ค.
  3. ํ•ฉ์น ๋•Œ๋Š” ํ•ฉ์น  ๋‘ ๋ฐฐ์—ด์˜ ๊ธธ์ด์˜ ์ดํ•ฉ๋งŒํผ์˜ ๋ณ„๋„ ๋ฐฐ์—ด์„ ์ค€๋น„ํ•ด์„œ ๋‘ ๋ฐฐ์—ด์—์„œ ์ž‘์€ ์ˆœ์„œ๋Œ€๋กœ ๊ฐ€์ ธ์™€์„œ ๋ฐฐ์—ด์— ๋„ฃ์–ด์ค€๋‹ค.

Example

๋ง๋กœ๋งŒ ํ•˜๋ฉด ํ—ท๊ฐˆ๋ฆฌ๋‹ˆ๊นŒ ์•„๋ž˜ ๋ฐฐ์—ด์„ ๋จธ์ง€์†ŒํŠธ๋กœ ์ •๋ ฌํ•˜๋Š” ๊ณผ์ •์„ ๋”ฐ๋ผ๊ฐ€๋ณด์ž.

 

Phase 1

๋จผ์ € ๋ฐฐ์—ด์„ ๋ฐ˜์œผ๋กœ ๋‚˜๋ˆˆ๋‹ค.

Phase 2

๋ฐฐ์—ด์˜ ๊ธธ์ด๊ฐ€ 1์ด ๋˜์ง€ ์•Š์•˜๊ธฐ ๋•Œ๋ฌธ์— ๋‚˜๋ˆ„์–ด์ง„ ๋ฐฐ์—ด์„ ๊ฐ๊ฐ ํ•œ๋ฒˆ ๋” ๋‚˜๋ˆˆ๋‹ค

Phase 3

3๊ณผ 1์€ ๊ธธ์ด๊ฐ€ 1์ด ๋˜์—ˆ๊ธฐ ๋•Œ๋ฌธ์— ๋ถ„ํ• ์„ ๋ฉˆ์ถ”๊ณ  ๋‚˜๋จธ์ง€ ๋ฐฐ์—ด๋“ค์€ ๋‹ค์‹œ ํ•œ๋ฒˆ ๋” ๋ฐ˜์œผ๋กœ ๋‚˜๋ˆ„์–ด์„œ ๋ถ„ํ• ํ•œ๋‹ค.

Phase 4

๋ถ„ํ• ๋œ ๋ชจ๋“  ๋ฐฐ์—ด์˜ ๊ธธ์ด๊ฐ€ 1์ด๋˜์—ˆ๊ธฐ ๋•Œ๋ฌธ์— ๋ถ„ํ• ์„ ๋ฉˆ์ถ”๊ณ , ๋งˆ์ง€๋ง‰์œผ๋กœ ๋ถ„ํ• ๋œ ๋ฐฐ์—ด๋ถ€ํ„ฐ ๋‹ค์‹œ ํ•ฉ์ณ์ค€๋‹ค. ์ด๋•Œ ํ•ฉ์น  ๋‘ ๋ฐฐ์—ด์˜ ๊ธธ์ด์˜ ์ดํ•ฉ ๋งŒํผ์˜ ๋ณ„๋„์˜ ๋ฐฐ์—ด์„ ์ค€๋น„ํ•˜๊ณ , ๊ฐ ๋ฐฐ์—ด ์š”์†Œ๋ฅผ ๋น„๊ตํ•ด์„œ ๋” ์ž‘์€ ์š”์†Œ๋ถ€ํ„ฐ ์ƒˆ๋กœ์šด ๋ฐฐ์—ด์— ๋„ฃ์–ด์ค€๋‹ค. ์ด ๊ฒฝ์šฐ์—์„œ๋Š” 6๊ณผ 7์„ ๋น„๊ตํ–ˆ์„ ๋•Œ 6์ด ๋” ์ž‘๊ธฐ ๋•Œ๋ฌธ์— ์ƒˆ๋กœ์šด ๋ฐฐ์—ด์— 0๋ฒˆ์งธ ์ด๋ฑ์Šค์— 6์„ ๋„ฃ๊ณ  1๋ฒˆ์งธ ์ธ๋ฑ์Šค์— 7์„ ๋„ฃ์—ˆ๋‹ค.

Phase 5

๋‹ค์Œ ๋ฐฐ์—ด๋„ ๊ฐ™์€ ๋ฐฉ๋ฒ•์œผ๋กœ ํ•ฉ์ณ์ค€๋‹ค.

Phase 6

๊ณ„์†ํ•ด์„œ ํ•ฉ์น˜๋Š” ๊ณผ์ •์„ ํ•ด์ฃผ๋Š”๋ฐ ์ง€๊ธˆ๋ถ€ํ„ฐ๋Š” ๋ฐฐ์—ด์˜ ๊ธธ์ด๊ฐ€ ๋Š˜์–ด๋‚˜์„œ ์กฐ๊ธˆ ํ—ท๊ฐˆ๋ฆด ์ˆ˜๋„ ์žˆ๋‹ค. ํ•ฉ์น˜๋Š” ๊ณผ์ •์€ ์ •ํ™•ํ•˜๊ฒŒ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ง„ํ–‰๋œ๋‹ค.
  1. ํ•ฉ์ณ์•ผํ•  ๋‘ ๋ฐฐ์—ด์˜ ๊ธธ์ด๊ฐ€ ๊ฐ๊ฐ 1, 2 ์ด๋ฏ€๋กœ ๊ธธ์ด 3์งœ๋ฆฌ ๋ฐฐ์—ด์„ ์ค€๋น„ํ•œ๋‹ค.
  2. ๋จผ์ € ๊ฐ ๋ฐฐ์—ด์˜ ์ฒ˜์Œ ๊ฐ’์ธ 3๊ณผ 2๋ฅผ ๋น„๊ตํ•œ๋‹ค. 2๊ฐ€ ๋” ์ž‘๊ธฐ ๋•Œ๋ฌธ์— 2๋ฅผ ์ƒˆ๋กœ์šด ๋ฐฐ์—ด์— ๋จผ์ € ๋„ฃ์–ด์ค€๋‹ค.
  3. 2 ๋‹ค์Œ์— ๊ฐ’์ด ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ์ด๋ฒˆ์—๋Š” 3๊ณผ 5๋ฅผ ๋น„๊ตํ•ด์„œ ๋” ์ž‘์€ ๊ฐ’์„ ๋ฐฐ์—ด์— ๋„ฃ๋Š”๋‹ค.
  4. ๋‚จ์€ ๊ฐ’์ด ํ•˜๋‚˜์ด๋ฏ€๋กœ ์ด ๊ฐ’์„ ๋งˆ์ง€๋ง‰์œผ๋กœ ๋ฐฐ์—ด์— ๋„ฃ๋Š”๋‹ค.

Phase 7 and More on

๊ณ„์† ์ง„ํ–‰ํ•˜๋‹ค๋ณด๋ฉด ๋งˆ์ง€๋ง‰์œผ๋กœ ํ•ฉ์ณ์ฃผ๋Š” ๊ตฌ๊ฐ„์ด ๋‚˜์˜ค๋Š”๋ฐ, ํ•ฉ์ณ์ฃผ๋Š” ๊ณผ์ •์„ ๋” ์ƒ์„ธํ•˜๊ฒŒ ๋ณด๊ธฐ ์œ„ํ•ด ์ด ๊ตฌ๊ฐ„์—์„œ ํ•ฉ์น˜๋Š” ๊ณผ์ •์„ ํ•œ๋‹จ๊ณ„์”ฉ ์ž์„ธํžˆ ํ™•์ธํ•ด๋ณด์ž. ์ผ๋‹จ ๋‘ ๋ฐฐ์—ด์˜ ๊ธธ์ด์˜ ํ•ฉ์ธ 6๋งŒํผ์˜ ์ƒˆ๋กœ์šด ๋ฐฐ์—ด์„ ๋งŒ๋“ค์—ˆ๋‹ค.

Step 1

๋‘ ๋ฐฐ์—ด์˜ ์‹œ์ž‘ ๊ฐ’์ธ 2์™€ 1์„ ๋น„๊ตํ•ด์„œ ๋” ์ž‘์€ ๊ฐ’์„ ์ƒˆ ๋ฐฐ์—ด์— ๋„ฃ์–ด์ค€๋‹ค.

Step 2

1์€ ์ด๋ฏธ ์‚ฌ์šฉ๋œ ๊ฐ’์ด๋‹ˆ๊นŒ ๊ฒ€์‚ฌ ๊ฐ’์„ ๋ฐฐ์—ด์˜ ๋‹ค์Œ๊ฐ’์œผ๋กœ ๋ฐ”๊ฟ”์ค€๋‹ค.

Step 3

์œ„์™€ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ 2 ์™€ 6์„ ๋น„๊ตํ•˜๊ณ  ๋” ์ž‘์€ ๊ฐ’์ธ 2๋ฅผ ์ƒˆ ๋ฐฐ์—ด์— ๋„ฃ์€ ๋’ค, ๋ฐฐ์—ด์˜ ์ฐธ์กฐ์œ„์น˜๋ฅผ ํ•œ์นธ ์ด๋™์‹œํ‚จ๋‹ค.

Step 4

3๊ณผ 6์ค‘ ๋” ์ž‘์€ ๊ฐ’์ธ 3์„ ๋ฐฐ์—ด์— ๋„ฃ๊ณ  ์ฐธ์กฐ๊ฐ’์„ ํ•œ์นธ ๋’ค๋กœ ์ด๋™์‹œํ‚จ๋‹ค.

Step 5

5์™€ 6 ์ค‘ ๋” ์ž‘์€ ๊ฐ’์ธ 5๋ฅผ ๋ฐฐ์—ด์— ๋„ฃ๋Š”๋‹ค. ์ด๋ฒˆ์—๋Š” 5๊ฐ€ ๋งˆ์ง€๋ง‰ ๊ฐ’์ด๊ธฐ ๋•Œ๋ฌธ์— ๊ทธ๋ƒฅ ๋๋‚ธ๋‹ค.

Step 6

์™ผ์ชฝ ๋ฐฐ์—ด์˜ ๋ชจ๋“  ์š”์†Œ์— ๋Œ€ํ•œ ์ฒ˜๋ฆฌ๊ฐ€ ๋๋‚ฌ๊ธฐ ๋•Œ๋ฌธ์— ์˜ค๋ฅธ์ชฝ ๋ฐฐ์—ด์—์„œ ์ฒ˜๋ฆฌ๊ฐ€ ์•ˆ๋œ ๊ฐ’๋“ค์„ ์ˆœ์ฐจ์ ์œผ๋กœ ์ƒˆ ๋ฐฐ์—ด์— ์ฑ„์›Œ์ค€๋‹ค. ์ด๋ฏธ ์˜ค๋ฅธ์ชฝ ๋ฐฐ์—ด์€ ๋ณ‘ํ•ฉํ•˜๋Š” ๊ณผ์ •์—์„œ ์ •๋ ฌ์ด ๋˜์–ด์žˆ๊ธฐ ๋•Œ๋ฌธ์— ์ˆœ์„œ๋Œ€๋กœ ๋„ฃ์–ด์ฃผ๊ธฐ๋งŒ ํ•ด๋„ ์ •๋ ฌ์€ ์œ ์ง€๋œ๋‹ค.

Implmentation

void merge (vector<int> & list, int left, int mid, int right){
  vector<int> sorted_list(list.size());
  int i = left, j = mid+1, idx = left;
  while(i <= mid && j <= right){
    if (list[i] <= list[j]){
      sorted_list[idx++] = list[i++];
    }
    else{
      sorted_list[idx++] = list[j++];
    }
  }
  while(i <= mid){
    sorted_list[idx++] = list[i++];
  }
  
  while(j <= right){
    sorted_list[idx++] = list[j++];
  }
  
  for (int l = left ; l <= right ; l++){
    list[l] = sorted_list[l];
  }
}

void partition (vector<int> & list, int left, int right){
  int mid;
  if (left < right){
    mid = (left + right) / 2;
    partition(list, left, mid);
    partition(list, mid+1, right);
    merge(list, left, mid, right);
  }
}

Alogrithm Analysis

๋จธ์ง€์†ŒํŠธ์˜ ์‹œ๊ฐ„ ๋ณต์žก๋„๋Š” ๋ฐฐ์—ด์„ ๊ณ„์†ํ•ด์„œ ๋ฐ˜์œผ๋กœ ๋ถ„๋ฆฌํ•˜๊ธฐ ๋•Œ๋ฌธ์˜ ์™„์ „์ด์ง„ํŠธ๋ฆฌ์˜ ๋†’์ด์ธ lgn ๊ณผ ๋น„๊ต์—ฐ์‚ฐ์„ ํ†ตํ•ด ์ƒˆ๋กœ์šด ๋ฐฐ์—ด์„ ์ฑ„์šฐ๋Š” ๊ณผ์ •์ด ๋ชจ๋“  ๋‹จ๊ณ„๋งˆ๋‹ค ์ˆ˜ํ–‰๋˜๊ธฐ ๋•Œ๋ฌธ์— ๐›ฉ(nlgn) ์˜ ๋ณต์žก๋„๋ฅผ ๊ฐ€์ง„๋‹ค.