ํต ์ ๋ ฌ์ ๊ฐ๋
ํต์ ๋ ฌ์ด๋?
๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ์ ํ๋๋ก, ํ๊ท ์ ์ผ๋ก ๋งค์ฐ ๋น ๋ฅธ ์ํ์๋๋ฅผ ๋ณด์ธ๋ค.
ํ์ง๋ง ์ญ์์ผ๋ก ์ ๋ ฌ๋๊ฑฐ๋ ์ด๋ฏธ ์ ๋ ฌ๋ ๋ฐ์ดํฐ๊ฐ ๋ค์ด์ค๋ฉด ๋นํจ์จ์ ์ด๋ค.(๋ถ๊ท ํ ๋ถํ ์ด ์ผ์ด๋จ)
๋ณํฉ์ ๋ ฌ๊ณผ ๋ค๋ฅด๊ฒ ๋๊ฐ์ ํฌ๊ธฐ์ ๋ฆฌ์คํธ๋ก ๋๋๋ ๊ฒ์ด ์๋, ํผ๋ด์ ๊ธฐ์ค์ผ๋ก ๋ฆฌ์คํธ๋ฅผ ๋๋๊ฒ ๋๋ค.
๋ณํฉ์ ๋ ฌ์ ๋ฐฐ์ด์ ์ฐ์ ๊ฐ์ฅ ์์ ๋จ์๋ก ๋๋ ํ์ ๋ฐ์ดํฐ๋ค์ด ์ ๋ ฌ๋๋ ๋ฐ๋ฉด์, ํต ์ ๋ ฌ์ ๋ฐ์ดํฐ๋ฅผ ์กฐ๊ฑด์ ๋ง๊ฒ ์ ๋ ฌ ํ ์์ ๋จ์๋ก ๋๋๋ค.
๋์ ๋ฐฉ์(์ค๋ฆ์ฐจ์ ์ ๋ ฌ)
- ๋ฆฌ์คํธ ์์ ์๋ ํ ์์๋ฅผ ํผ๋ด์ผ๋ก ์ ํํ๋ค. (์ ๋ ฌ์ ์ํ ๊ธฐ์ค์ด๋ผ๊ณ ๋ณด๋ฉด ๋๋ค)
- ํผ๋ด์ ๊ธฐ์ค์ผ๋ก ํผ๋ด๋ณด๋ค ์์ ์์๋ค์ ์ผ์ชฝ์ผ๋ก, ํผ๋ด๋ณด๋ค ํฐ ์์๋ค์ ํผ๋ด๋ค์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ฎ๊ฒจ์ง๋ค.
- ํผ๋ด์ ์ ์ธํ ์ผ์ชฝ ๋ฆฌ์คํธ์ ์ค๋ฅธ์ชฝ ๋ฆฌ์คํธ์ ๋ํด์ ๊ฐ๊ฐ ์ ๋ ฌ์ ์ํํ๋ค.
- ์์ ๊ณผ์ ์ ์ฌ๊ท ํธ์ถ์ ์ด์ฉํ์ฌ ๋ฆฌ์คํธ์ ํฌ๊ธฐ๊ฐ ๊ฐ์ฅ ์์ ๋จ์๋ก ์ชผ๊ฐ์ง ๋ ๊น์ง ๋ฐ๋ณตํ๋ค.
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)์ด๋ค.
ํต์ ๋ ฌ์ ์ฅ๋จ์
์ฅ์
- ํ ๋ฒ ๊ฒฐ์ ๋ ํผ๋ด๋ค์ด ์ถํ ์ฐ์ฐ์์ ์ ์ธ๋๋ฏ๋ก ๊ฐ์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ๋ ์ ๋ ฌ ์ค ๊ฐ์ฅ ๋น ๋ฅด๋ค.
- ๋ณํฉ ์ ๋ ฌ๊ณผ ๊ณตํต์ ์ธ ์ ๊ทผ ๋ฐฉ์์ด์ง๋ง, ์ถ๊ฐ์ ์ธ ์ ์ฅ๊ณต๊ฐ์ ์ฐ์ง ์๋๋ค.
๋จ์
- ๋ถ๊ท ํ ๋ถํ ์ด ์ผ์ด๋ ๊ฒฝ์ฐ ๋นํจ์จ์ ์ด๋ค.
- ํนํ ์ด๋ฏธ ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ ์ญ์์ธ ๋ฆฌ์คํธ์ ๋ํด์ ๊ณผ๋ํ ์ํ์๊ฐ์ด ๊ฑธ๋ฆฐ๋ค.
- Unstable Sort์ด๋ค.