ํต ์ ๋ ฌ(Quick Sort)
ํต ์ ๋ ฌ์ ํฉ๋ณ์ ๋ ฌ๊ณผ ๋น์ทํ๊ฒ ๋ถํ ์ ๋ณต(Divide and Conquer) ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
ํ๊ท ์ ์ผ๋ก ๋งค์ฐ ๋น ๋ฅธ ์ํ ์๋๋ฅผ ์๋ํ๋ ์ ๋ ฌ ๋ฐฉ๋ฒ์ผ๋ก ๋ค์๊ณผ ๊ฐ์ ๊ณผ์ ์ ๊ฑฐ์น๋ค.
1. ๋ฆฌ์คํธ ์์ ์๋ ํ ์์๋ฅผ ์ ํํ๋ค. ์ด๋ ๊ฒ ๊ณ ๋ฅธ ์์๋ฅผ pivot์ด๋ผ๊ณ ํ๋ค.
2. pivot์ ๊ธฐ์ค์ผ๋ก pivot๋ณด๋ค ์์ ์์๋ค์ ๋ชจ๋ pivot์ ์ผ์ชฝ์ผ๋ก ์ฎ๊ธฐ๊ณ pivot๋ณด๋ค ํฐ ์์๋ค์ ๋ชจ๋ povot์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ฎ๊ธด๋ค.
3. pivot์ ์ ์ธํ ์ผ์ชฝ ๋ฆฌ์คํธ์ ์ค๋ฅธ์ชฝ ๋ฆฌ์คํธ๋ฅผ ๋ค์ ์ ๋ ฌํ๋ค.
3-1) ๋ถํ ๋ ์ผ์ชฝ ๋ฆฌ์คํธ์ ์ค๋ฅธ์ชฝ๋ฆฌ์คํธ๋ ๋ค์ pivot์ ์ ํ๊ณ pivot์ ๊ธฐ์ค์ผ๋ก 2๊ฐ์ ๋ถ๋ถ๋ฆฌ์คํธ๋ก ๋๋๋ค.
3-2) ์ฌ๊ท๋ฅผ ์ฌ์ฉํ์ฌ ๋ถ๋ถ ๋ฆฌ์คํธ๋ค์ด ๋์ด์ ๋ถํ ์ด ๋ถ๊ฐ๋ฅ ํ ๋๊น์ง ๋ฐ๋ณตํ๋ค.
์์ ๊ฐ์ ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ํต์ ๋ ฌํ๋ค๊ณ ์น์. ๊ฐ์ฅ ๋จผ์ pivot์ ์ค์ ํด์ผ ํ๋๋ฐ, pivot์ ์ค์ ํ๋ ๊ฒ์๋ ์ฌ๋ฌ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์๋ค. ๊ฐ์ฅ ์์ ์์, ์ค๊ฐ ์์, ํน์ ๊ฐ์ฅ ๋ค์ ์์๋ฅผ ํํ๋ ๋ฑ์ ๋ฐฉ๋ฒ์ด ์๋๋ฐ ์ฌ๊ธฐ์๋ ์ค๊ฐ ์์๋ฅผ pivot๊ฐ์ผ๋ก ์ค์ ํ๋ ๊ฒ์ ํํ๊ฒ ๋ค.
- ์ค๊ฐ ๊ฐ์ pivot์ผ๋ก ์ค์ ํ๋ค๋ฉด ๊ฐ์ฅ ์ผ์ชฝ์ ๊ฐ์ left, ์ค๋ฅธ์ชฝ์ ๊ฐ์ right๋ก ์ก๋๋ค.
- left๋ ์ค๋ฅธ์ชฝ์ผ๋ก, right๋ ์ผ์ชฝ์ผ๋ก ์ด๋ํ๊ฒ ๋๋๋ฐ ์ด๋
- left๋ pivot๋ณด๋ค ํฐ ์๋ฅผ ๋ง๋๊ฑฐ๋ pivot์ ๋ง๋๋ฉด ๋ฉ์ถ๊ณ
- right๋ pivot๋ณด๋ค ์์ ์๋ฅผ ๋ง๋๊ฑฐ๋ pivot์ ๋ง๋๋ฉด ๋ฉ์ถ๋ค.
- ๋ฐ๋ผ์ 5๊ฐ 3๋ณด๋ค ํฌ๋ฏ๋ก left๋ 5์์ ๋ฉ์ถ๊ณ , 2๊ฐ 3๋ณด๋ค ์์ผ๋ฏ๋ก right๋ 2์์ ๋ฉ์ถ๋ค.
- left์ right๊ฐ ๋ฉ์ท์ ๋, left๊ฐ right๋ณด๋ค ์ผ์ชฝ์ ์๋ค๋ฉด elft์ right๊ฐ์ ๊ตํํด์ค๋ค.
- ์ดํ left๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก ํ์นธ, right๋ฅผ ์ผ์ชฝ์ผ๋ก ํ ์นธ ์ด๋ํด์ค๋ค.
- ์ ๊ณผ์ ์ left๊ฐ right๋ณด๋ค ์ค๋ฅธ์ชฝ์ผ๋ก ์ฌ ๋๊น์ง ๋ฐ๋ณตํ๋ค.
- 6์ด 3๋ณด๋ค ํฌ๋ฏ๋ก 6์์ left๊ฐ ๋ฉ์ถ๋ค.
- right๋ pivot์ ๋ง๋์ ๋ฉ์ถ๋ค.
- ์ด ๋ left๊ฐ right๋ณด๋ค ์ผ์ชฝ์ ์์ผ๋ฏ๋ก left์ right๊ฐ์ ๊ตํํ๋ค.
- left๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ. right๋ฅผ ์ผ์ชฝ์ผ๋ก ํ ์นธ ์ด๋ํ๋ค.
- left๊ฐ right๋ณด๋ค ์ค๋ฅธ์ชฝ์ ์์ผ๋ฏ๋ก ์ข ๋ฃํ๋ค.
right๊ฐ L๋ณด๋ค ํฌ๋ค๋ฉด L๋ถํฐ right๊น์ง ๋ค์ ์ ๊ณผ์ ์ ์ฌ๊ท์ ์ผ๋ก ๋ฐ๋ณตํ๋ค.
left๊ฐ R๋ณด๋ค ์๋ค๋ฉด left๋ถํฐ R๊น์ง ๋ค์ ์ ๊ณผ์ ์ ์ฌ๊ท์ ์ผ๋ก ๋ฐ๋ณตํ๋ค.
์ผ์ชฝ ๋ถ๋ถ ๋ฐฐ์ด ์ ๋ ฌ ๊ณผ์
- LEFT๋ 2์์ ๋ฉ์ถ๋ค.
- RIGHT๋ PIVOT์์ ๋ฉ์ถ๋ค.
- LEFT๊ฐ RIGHT๋ณด๋ค ์ผ์ชฝ์ ์์ผ๋ฏ๋ก ๋์ ๊ตํํ๋ค.
- LEFT๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก ํ์นธ, RIGHT๋ฅผ ์ผ์ชฝ์ผ๋ก ํ์นธ ์ด๋ํ๋ค.
- LEFT๊ฐ RIGHT๋ณด๋ค ์ค๋ฅธ์ชฝ์ ์์ผ๋ฏ๋ก ์ข ๋ฃํ๋ค.
- ์ด๋ RIGHT๊ฐ L๋ณด๋ค ํฌ์ง ์์ผ๋ฏ๋ก ์ผ์ชฝ๋ฐฐ์ด(L๋ถํฐ RIGHT)๋ ๋ค์ ์ฌ๊ท์ ์ผ๋ก ์ ๋ ฌํ ํ์๊ฐ ์๋ค.
- LEFT๋ R๋ณด๋ค ์์ผ๋ฏ๋ก LEFT๋ถํฐ R๊น์ง ๋ค์ ์ฌ๊ท์ ์ผ๋ก ์ ๋ ฌ์ ์ํํ๋ค.
์ค๋ฅธ์ชฝ ๋ถ๋ถ ๋ฐฐ์ด ์ ๋ ฌ ๊ณผ์
- LEFT๋ 6์์ ๋ฉ์ถ๋ค.
- RIGHT๋ PIVOT์์ ๋ฉ์ถ๋ค.
- LEFT๊ฐ RIGHT๋ณด๋ค ์ผ์ชฝ์ ์์ผ๋ฏ๋ก ๋์ ๊ตํํ๋ค.
- LEFT๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ, RIGHT๋ฅผ ์ผ์ชฝ์ผ๋ก ํ์นธ ์ด๋ํ๋ค.
- LEFT๊ฐ RIGHT๋ณด๋ค ์ค๋ฅธ์ชฝ์ ์์ผ๋ฏ๋ก ์ข ๋ฃํ๋ค.
- ์ด๋ RIGHT๊ฐ L๋ณด๋ค ํฌ์ง ์์ผ๋ฏ๋ก ์ผ์ชฝ ๋ฐฐ์ด (L๋ถํฐ RIGHT)์ ์ฌ๊ท์ ์ผ๋ก ์ ๋ ฌํ ํ์๊ฐ ์๋ค.
- LEFT๋ R๋ณด๋ค ์์ผ๋ฏ๋ก LEFT๋ถํฐ R๊น์ง ๋ค์ ์ฌ๊ท์ ์ผ๋ก ์ ๋ ฌ์ ์ํํ๋ค.
ํต ์ ๋ ฌ ํน์ง
- ํต์ ๋ ฌ์ ์ฌ๊ท์ ์ผ๋ก ์ ์๋๋ฏ๋ก ์ฌ๊ท ํธ์ถ์ ๋ฐ๋ฅธ ์คํ์ด ์ฌ์ฉ๋๋ค. ์ด๋ ์คํ์ ๊น์ด๋ N๊ฐ์ ์์์ ๋ํด logN์ ๋น๋กํ๋ฏ๋ก ๊ณต๊ฐ๋ณต์ก๋๋ O(NlogN)์ด๋ค. ๋ฐ๋ผ์ in-place ์ ๋ ฌ์ด๋ผ๊ณ ํ๊ธฐ ํ๋ค์ง๋ง, ์ค์ฉ์ ์ผ๋ก๋ ์๋์ ์ผ๋ก ์์ ๋ฉ๋ชจ๋ฆฌ๋ง์ ์ฌ์ฉํ๋ฏ๋ก ํํ in-place ์ ๋ ฌ์ด๋ผ๊ณ ๊ธฐ์ ํ๊ธฐ๋ ํ๋ค.
- ํต์ ๋ ฌ์ ์ต์ ์ ๊ฒฝ์ฐ pivot์ด ๋ฐฐ์ด ๋ด์์ ๊ฐ์ฅ ์์ ๊ฐ ๋๋ ๊ฐ์ฅ ํฐ ๊ฐ์ผ๋ก ์ค์ ๋๋ค๋ฉด ์์ n๊ฐ์ ๋ํด์ n๋ฒ, (n-1), (n-2)...1๋ฒ์ ๋น๊ต๊ฐ ํ์ํ๋ฏ๋ก ์๊ฐ๋ณต์ก๋๊ฐ O(N^2)์ด ๋๋ค.
- ํ์ง๋ง ํ๊ท ์๊ฐ๋ณต์ก๋๋ O(NlogN)์ผ๋ก ๋งค์ฐ ๋น ๋ฅด๋ค. pivot ๊ฐ์ด ์ ์ ํ ์ค์ ๋๋ค๋ฉด ๊ทธ ์๋๊ฐ ๋งค์ฐ ๋น ๋ฅด๋ค. ๋ฐ๋ผ์ pivot๊ฐ์ ์ ์ค์ ํ๋ ๊ฒ์ด ์ค์ํ๋ค.
- ํต์ ๋ ฌ์ ์ค๋ณต๋ ํค๊ฐ์ด ์์๋๋ก ๋ฐ๋์ง ์์ ์ ์์ด not-stableํ๋ค.
ํต ์ ๋ ฌ ์ฝ๋
void quickSort(int arr[], int L, int R) {
int left = L, right = R;
int pivot = arr[(L + R) / 2];
int temp;
do {
while (arr[left] < pivot) //left๊ฐ pivot ๋ณด๋ค ํฐ ๊ฐ์ ๋ง๋๊ฑฐ๋ pivot์ ๋ง๋ ๋ ๊น์ง
left++;
while (arr[right] > pivot)//right๊ฐ pivot๋ณด๋ค ์์ ๊ฐ์ ๋ง๋๊ฑฐ๋ pivot์ ๋ง๋ ๋ ๊น์ง
right--;
if (left <= right) { //left๊ฐ right๋ณด๋ค ์ผ์ชฝ์ ์๋ค๋ฉด ๊ตํ
temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++; //์ค๋ฅธ์ชฝ์ผ๋ก ํ์นธ
right--;//์ผ์ชฝ์ผ๋ก ํ์นธ
}
} while (left <= right); //left๊ฐ right๋ณด๋ค ์ค๋ฅธ์ชฝ์ ์์ ๋ ๊น์ง ๋ฐ๋ณต
if (L < right)
quickSort(arr, L, right); //์ผ์ชฝ๋ฐฐ์ด ์ฌ๊ท์ ์ผ๋ก ๋ฐ๋ณต
if (left < R)
quickSort(arr, left, R); // ์ค๋ฅธ์ชฝ ๋ฐฐ์ด ์ฌ๊ท์ ์ผ๋ก ๋ฐ๋ณต
}