[์ •๋ ฌ] Quick Sort

ํ€ต ์ •๋ ฌ์˜ ๊ฐœ๋…

ํ€ต์ •๋ ฌ Worst-case, ๋ถˆ๊ท ํ˜• ๋ถ„ํ• 

ํ€ต์ •๋ ฌ์ด๋ž€?

๋ถ„ํ•  ์ •๋ณต ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ํ•˜๋‚˜๋กœ, ํ‰๊ท ์ ์œผ๋กœ ๋งค์šฐ ๋น ๋ฅธ ์ˆ˜ํ–‰์†๋„๋ฅผ ๋ณด์ธ๋‹ค.
ํ•˜์ง€๋งŒ ์—ญ์ˆœ์œผ๋กœ ์ •๋ ฌ๋˜๊ฑฐ๋‚˜ ์ด๋ฏธ ์ •๋ ฌ๋œ ๋ฐ์ดํ„ฐ๊ฐ€ ๋“ค์–ด์˜ค๋ฉด ๋น„ํšจ์œจ์ ์ด๋‹ค.(๋ถˆ๊ท ํ˜• ๋ถ„ํ• ์ด ์ผ์–ด๋‚จ)
๋ณ‘ํ•ฉ์ •๋ ฌ๊ณผ ๋‹ค๋ฅด๊ฒŒ ๋˜‘๊ฐ™์€ ํฌ๊ธฐ์˜ ๋ฆฌ์ŠคํŠธ๋กœ ๋‚˜๋ˆ„๋Š” ๊ฒƒ์ด ์•„๋‹Œ, ํ”ผ๋ด‡์„ ๊ธฐ์ค€์œผ๋กœ ๋ฆฌ์ŠคํŠธ๋ฅผ ๋‚˜๋ˆ„๊ฒŒ ๋œ๋‹ค.
๋ณ‘ํ•ฉ์ •๋ ฌ์€ ๋ฐฐ์—ด์„ ์šฐ์„  ๊ฐ€์žฅ ์ž‘์€ ๋‹จ์œ„๋กœ ๋‚˜๋ˆˆ ํ›„์— ๋ฐ์ดํ„ฐ๋“ค์ด ์ •๋ ฌ๋˜๋Š” ๋ฐ˜๋ฉด์—, ํ€ต ์ •๋ ฌ์€ ๋ฐ์ดํ„ฐ๋ฅผ ์กฐ๊ฑด์— ๋งž๊ฒŒ ์ •๋ ฌ ํ›„ ์ž‘์€ ๋‹จ์œ„๋กœ ๋‚˜๋ˆˆ๋‹ค.

๋™์ž‘ ๋ฐฉ์‹(์˜ค๋ฆ„์ฐจ์ˆœ ์ •๋ ฌ)

  1. ๋ฆฌ์ŠคํŠธ ์•ˆ์— ์žˆ๋Š” ํ•œ ์š”์†Œ๋ฅผ ํ”ผ๋ด‡์œผ๋กœ ์„ ํƒํ•œ๋‹ค. (์ •๋ ฌ์„ ์œ„ํ•œ ๊ธฐ์ค€์ด๋ผ๊ณ  ๋ณด๋ฉด ๋œ๋‹ค)
  2. ํ”ผ๋ด‡์„ ๊ธฐ์ค€์œผ๋กœ ํ”ผ๋ด‡๋ณด๋‹ค ์ž‘์€ ์š”์†Œ๋“ค์€ ์™ผ์ชฝ์œผ๋กœ, ํ”ผ๋ด‡๋ณด๋‹ค ํฐ ์š”์†Œ๋“ค์€ ํ”ผ๋ด‡๋“ค์˜ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ์˜ฎ๊ฒจ์ง„๋‹ค. 
  3. ํ”ผ๋ด‡์„ ์ œ์™ธํ•œ ์™ผ์ชฝ ๋ฆฌ์ŠคํŠธ์™€ ์˜ค๋ฅธ์ชฝ ๋ฆฌ์ŠคํŠธ์— ๋Œ€ํ•ด์„œ ๊ฐ๊ฐ ์ •๋ ฌ์„ ์ˆ˜ํ–‰ํ•œ๋‹ค.
  4. ์œ„์˜ ๊ณผ์ •์„ ์žฌ๊ท€ ํ˜ธ์ถœ์„ ์ด์šฉํ•˜์—ฌ ๋ฆฌ์ŠคํŠธ์˜ ํฌ๊ธฐ๊ฐ€ ๊ฐ€์žฅ ์ž‘์€ ๋‹จ์œ„๋กœ ์ชผ๊ฐœ์งˆ ๋•Œ ๊นŒ์ง€ ๋ฐ˜๋ณตํ•œ๋‹ค. 

2๋ฒˆ ๊ณผ์ •์„ ํ•œ๋ฒˆ ์ˆ˜ํ–‰ํ•  ๋•Œ๋งˆ๋‹ค ์ตœ์†Œ ๋ฐ์ดํ„ฐ(ํ”ผ๋ด‡) ํ•œ๊ฐœ์˜ ์œ„์น˜๊ฐ€ ๋ฌด์กฐ๊ฑด ์ •ํ•ด์ง€๋ฏ€๋กœ ๋ฐ˜๋“œ์‹œ ์ •๋ ฌ์ด ์ด๋ฃจ์–ด์ง„๋‹ค.

ํ€ต ์ •๋ ฌ ๊ตฌํ˜„ 

    private void divide(int left, int right) {
        if(left < right) {
            int pivot = sort(left, right);
            divide(left, pivot - 1);
            divide(pivot + 1, right);
        }
    }

    private int sort(int left, int right) {
        int key = numbers[right];
        int l = left, r = right;

        while(l < r) {
            while(l < r && key >= numbers[l]) {
                l++;
            }
            while (l < r && key <= numbers[r]) {
                r--;
            }
            if(l < r) SWAP(l,r);
        }

        numbers[right] = numbers[l];
        numbers[l] = key;

        return l;
    }

    private void SWAP(int a, int b) {
        int temp = numbers[a];
        numbers[a] = numbers[b];
        numbers[b] = temp;
    }

ํ€ต ์ •๋ ฌ์˜ ์‹œ๊ฐ„ ๋ณต์žก๋„

ํ€ต ์ •๋ ฌ์˜ Average-case 

์œ„ Average-case์˜ ์žฌ๊ท€ ํŠธ๋ฆฌ๋Š” 

n^k = n(k=lgn)

์ด๊ธฐ ๋•Œ๋ฌธ์— ๋†’์ด๋Š” lgn์ธ ๊ฒƒ์„ ์•Œ ์ˆ˜ ์žˆ๋‹ค. 

๊ทธ๋ฆฌ๊ณ  ๊ฐ level๋งˆ๋‹ค n๋ฒˆ์˜ ๋น„๊ต๊ฐ€ ๋ฌด์กฐ๊ฑด ๋ฐœ์ƒํ•˜๊ธฐ ๋•Œ๋ฌธ์— Average-case ์‹œ๊ฐ„ ๋ณต์žก๋„๋Š”

n * lgn์ธ O(nlgn)์ด๋‹ค.

ํ€ต ์ •๋ ฌ์˜ Worst-case 

์žฌ๊ท€ ํŠธ๋ฆฌ

๋”ฐ๋ผ์„œ worst-case ์ผ ๋•Œ Big-O๋Š”

O(n^2)์ด๋‹ค.

ํ€ต์ •๋ ฌ์˜ ์žฅ๋‹จ์ 

์žฅ์  

  1. ํ•œ ๋ฒˆ ๊ฒฐ์ •๋œ ํ”ผ๋ด‡๋“ค์ด ์ถ”ํ›„ ์—ฐ์‚ฐ์—์„œ ์ œ์™ธ๋˜๋ฏ€๋กœ ๊ฐ™์€ ์‹œ๊ฐ„ ๋ณต์žก๋„๋ฅผ ๊ฐ–๋Š” ์ •๋ ฌ ์ค‘ ๊ฐ€์žฅ ๋น ๋ฅด๋‹ค.
  2. ๋ณ‘ํ•ฉ ์ •๋ ฌ๊ณผ ๊ณตํ†ต์ ์ธ ์ ‘๊ทผ ๋ฐฉ์‹์ด์ง€๋งŒ, ์ถ”๊ฐ€์ ์ธ ์ €์žฅ๊ณต๊ฐ„์„ ์“ฐ์ง€ ์•Š๋Š”๋‹ค.

๋‹จ์ 

  1. ๋ถˆ๊ท ํ˜• ๋ถ„ํ• ์ด ์ผ์–ด๋‚  ๊ฒฝ์šฐ ๋น„ํšจ์œจ์ ์ด๋‹ค.
  2. ํŠนํžˆ ์ด๋ฏธ ์ •๋ ฌ๋œ ๋ฆฌ์ŠคํŠธ๋‚˜ ์—ญ์ˆœ์ธ ๋ฆฌ์ŠคํŠธ์— ๋Œ€ํ•ด์„œ ๊ณผ๋„ํ•œ ์ˆ˜ํ–‰์‹œ๊ฐ„์ด ๊ฑธ๋ฆฐ๋‹ค.
  3. Unstable Sort์ด๋‹ค.