ํต ์ ๋ ฌ (Quick Sort) ์๊ณ ๋ฆฌ์ฆ :
๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ ์ค์ ํ๋๋ก, ๋งค์ฐ ๋น ๋ฅธ ์๋๋ฅผ ์๋ํ๋ ์๊ณ ๋ฆฌ์ฆ
1. ๋ฐฐ์ด ์์ ํ ์์๋ฅผ ์ ํํ์ฌ ์ด๋ฅผ ํผ๋ฒ์ด๋ผ ํ๊ณ , ๋ฐฐ์ด์ ๋งจ ์ฒซ๋ฒ์งธ ์์์ ๊ตํ
2. ๋ฐฐ์ด์ ์ผ์ชฝ ๋์์๋ถํฐ ํผ๋ฒ๋ณด๋ค ํฐ ์์๋ฅผ, ์ค๋ฅธ์ชฝ ๋์์๋ถํฐ ํผ๋ฒ๋ณด๋ค ์์ ์์๋ฅผ ํ์
3. ์ผ์ชฝ์์ ๋ฐ๊ฒฌํ ํผ๋ฒ๋ณด๋ค ํฐ ์์์ ์ค๋ฅธ์ชฝ์์ ๋ฐ๊ฒฌํ ํผ๋ฒ๋ณด๋ค ์์ ์์๋ฅผ ๊ตํ
3. ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ์์ ํ์ํ๋ ์ปค์๊ฐ ๋ง๋๋ฉด ์ค์ง, ํผ๋ฒ๊ณผ ๊ตํ
=> ๋ ์ปค์๊ฐ ๋ง๋ ์์น ์ผ์ชฝ์๋ ํผ๋ฒ๋ณด๋ค ์์ ์์๊ฐ, ์ค๋ฅธ์ชฝ์๋ ํฐ ์์๊ฐ ์์นํ๊ฒ ๋๋ค
4. ํผ๋ฒ์ ๊ธฐ์ค์ผ๋ก ์ผ์ชฝ ๊ทธ๋ฃน๊ณผ ์ค๋ฅธ์ชฝ ๊ทธ๋ฃน์ ๊ฐ๊ฐ ๋ค์ ํต ์ ๋ ฌ
5. ๊ฐ ๊ทธ๋ฃน์ด ๋์ด์ ๋ถํ ์ด ๋ถ๊ฐ๋ฅํ ๋ ๊น์ง ๋ฐ๋ณต -> ๊ทธ๋ฃน ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ 0์ด๋ 1์ด๋ฉด ์ค์ง
int[] quick = {5, 1, 4, 3, 7, 6, 2}
1. quick ๋ฐฐ์ด์ ์ ๊ฐ์ด๋ฐ ์์๋ฅผ ํผ๋ฒ์ผ๋ก ์ ํ๊ณ ๋ฐฐ์ด์ ๋งจ ์ ์์์ ๊ตํ
2. ๋งจ ์ผ์ชฝ๋ถํฐ L์ปค์๊ฐ ํผ๋ฒ๋ณด๋ค ํฐ ๊ฐ์ ํ์, 4 ๋ฐ๊ฒฌ / ๋งจ ์ค๋ฅธ์ชฝ๋ถํฐ R ์ปค์๊ฐ ํผ๋ฒ๋ณด๋ค ์์ ๊ฐ์ ํ์, 2 ๋ฐ๊ฒฌ / ๋ ๊ฐ ๊ตํ
3. L์ปค์๊ฐ 5๋ฅผ ์ฐพ๊ณ R์ปค์๊ฐ 2๋ฅผ ์ฐพ์์ง๋ง, R์ปค์๊ฐ L์ปค์๋ณด๋ค ์ผ์ชฝ์ ์์น
4. ํผ๋ฒ๊ณผ R์ปค์ ์์น์ ์์ ๊ตํ
5. ํผ๋ฒ 3์ ๊ธฐ์ค์ผ๋ก ์ผ์ชฝ ๊ทธ๋ฃน๊ณผ ์ค๋ฅธ์ชฝ ๊ทธ๋ฃน์ ๊ฐ๊ฐ ํต ์ ๋ ฌ
๋ฉ์๋ swap() : a[idx1] ๊ณผ a[idx2] ๋ฅผ ๊ตํ
๋งค๊ฐ๋ณ์ : int[] a, int idx1, int idx2
๋ฉ์๋ partition() : ๋ฐฐ์ด a์ index left ๋ถํฐ right ๊น์ง ์์ ์ค ํผ๋ฒ์ ์ ํด ํต ์ ๋ ฌ ํ ํผ๋ฒ index ๋ฐํ
๋งค๊ฐ๋ณ์ : int[] a, int left, int right
๋ฐํ๊ฐ : ํต ์ ๋ ฌ ํ ํผ๋ฒ์ index
๋ฉ์๋ quickSort() : ๋ฐฐ์ด a์ index left ๋ถํฐ right ๊น์ง ์์๋ฅผ ํต ์ ๋ ฌ
๋งค๊ฐ๋ณ์ : int[] a, int left, int right
- ํต ์ ๋ ฌ :
void swap(int[] a, int idx1, int idx2) {
int t = a[idx1];
a[idx1] = a[idx2];
a[idx2] = t;
}
int partition(int[] a, int left, int right) {
int pc = (left + right)/2;
int pivot = a[pc];
int pl = left;
int pr = right;
swap(a, pl, pc);
while(pl < pr) {
while(a[pr] > pivot) pr--;
while(a[pl] <= pivot && pl < pr) pl++;
swap(a, pl, pr);
}
a[left] = a[pl];
a[pl] = pivot;
return pl;
}
void quickSort(int[] a, int left, int right) {
if(left >= right)
return;
int pc = partition(a, left, right);
quickSort(a, left, pc-1);
quickSort(a, pc+1, right);
}
ํต ์ ๋ ฌ Quick Sort :
์ต์ = O(NlogN), ํ๊ท = O(NlogN), ์ต์ = O(N^2)
๋ถ์์ ํ ์ ๋ ฌ