ํต ์ ๋ ฌ
์ด๋ฒ์๋ ํต ์ ๋ ฌ์ ๋ํด ์์๋ณด์. ํต ์ ๋ ฌ์ด๋ ๋ํ์ ์ธ '๋ถํ ์ ๋ณต'์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํ๊ท ์๋๊ฐ O(N*logN)์ธ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ์ด์ ์ ๋ฐฐ์ ๋ ์ ํ ์ ๋ ฌ, ๋ฒ๋ธ ์ ๋ ฌ, ์ฝ์ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ๋ฐ์ดํฐ์ ๊ฐฏ์๊ฐ 10๋ง๊ฐ๊ฐ ๋์ด๊ฐ๋ฉด ์ฌ์ฉํ๊ธฐ ๋งค์ฐ ์ด๋ ค์ด ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ๋ฐ๋ผ์ ๋์ฑ ๋น ๋ฅธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ด ํ์ํ๊ณ ๋ํ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ด ํต ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
๋ค์์ ์ซ์๋ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.
1 10 5 8 7 6 4 3 2 9
ํต ์ ๋ ฌ์ ํ๋์ ํฐ ๋ฌธ์ ๋ฅผ ๋๊ฐ์ ์์ ๋ฌธ์ ๋ก ๋ถํ ํ๋ ์์ผ๋ก ์ ๋ ฌํ๋ค. ๋ค์ ๋งํด ํน์ ํ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ํฐ ์ซ์์ ์์ ์ซ์๋ฅผ ์๋ก ๊ตํํ ๋ค์ ๋ฐฐ์ด์ ๋ฐ์ผ๋ก ๋๋๋ค.
์์๋ฅผ ํตํด ๋ณด์.
ํต ์ ๋ ฌ์๋ ๊ธฐ์ค ๊ฐ์ด ์ฌ์ฉ๋๋ค. ์ด๋ฅผ ํผ๋ฒ(Pivot)์ด๋ผ๊ณ ๋ ํ๋๋ฐ, ๋ณดํต ์ฒซ ๋ฒ์งธ ์์๋ฅผ ํผ๋ฒ ๊ฐ์ผ๋ก ์ค์ ํ๊ณ ์ฌ์ฉํ๋ค. ๋ฌธ์ ์ ๋ค๋ฅธ ๋ฐฐ์ด์ ์ฌ์ฉํด๋ณด์.
(3) 7 8 1 5 9 6 10 2 4
๋จผ์ 3(ํผ๋ฒ๊ฐ)๋ณด๋ค ํฐ ์ซ์๋ฅผ ์ผ์ชฝ๋ถํฐ ์ฐพ๊ณ , 3๋ณด๋ค ์์ ์ซ์๋ฅผ ์ค๋ฅธ์ชฝ๋ถํฐ ์ฐพ๋๋ค. ์ด๋ 3๋ณด๋ค ํฐ์ซ์๋ ๋ฐ๋ก 7, 3๋ณด๋ค ์์ ์ซ์๋ 2๊ฐ ๋์ค๋ฏ๋ก ๋์ ์๋ฆฌ๋ฅผ ๋ฐ๊ฟ์ค๋ค. ๋ค์๋ ๋๊ฐ์ด ํฐ ์ซ์๋ฅผ ์ผ์ชฝ๋ถํฐ ์ฐพ๊ณ , 3๋ณด๋ค ์์ ์ซ์๋ฅผ ์ค๋ฅธ์ชฝ๋ถํฐ ์ฐพ๋๋ค. 8๊ณผ 1์ ์๋ฆฌ๋ฅผ ๋ฐ๊ฟ์ค๋ค. ์ดํ ์ผ์ชฝ๋ถํฐ ์ฐพ์ ํฐ ์ซ์์ ์ค๋ฅธ์ชฝ๋ถํฐ ์ฐพ์ ์์ ์ซ์๊ฐ ์๊ฐ๋ฆฐ๋ค๋ฉด ํผ๋ฒ ๊ฐ๊ณผ ์์ ๊ฐ์ ์๋ฆฌ๋ฅผ ๋ฐ๊ฟ์ค๋ค. ์ด๋ ๊ฒ ํ๋ฉด 3์ ๊ธฐ์ค์ผ๋ก 3์ ์ผ์ชฝ์๋ 3๋ณด๋ค ์์ ๊ฐ๋ค์ด, 3์ ์ค๋ฅธ์ชฝ์๋ 3๋ณด๋ค ํฐ ๊ฐ๋ค์ด ์์นํ๊ฒ ๋๋ค. 3์ ๊ธฐ์ค์ผ๋ก ๋ถํ ๋ ๋ฐฐ์ด์ ๋ํด ๊ณ์ํด์ ๊ฐ์ ๊ณผ์ ์ ์งํํ๋ค.
#include <stdio.h>
int number = 10;
int data[] = {1, 10, 5, 8 , 7, 6, 4, 3, 2, 9};
void show(){
int i;
for(i=0; i<number; i++){
printf("%d",data[i]);
}
}
void quickSort(int* data, int start, int end){
if (start>=end){ // ์์๊ฐ 1๊ฐ์ธ ๊ฒฝ์ฐ ๊ทธ๋๋ก ๋๊ธฐ
return;
}
int key = start; // ํผ๋ฒ๊ฐ์ ์ฒซ๋ฒ์งธ ์์
int i = start +1, j=end,temp;
while(i<=j){// ์๊ฐ๋ฆด ๋ ๊น์ง ๋ฐ๋ณต
while(i<=end && data[i] <= data[key]){ //ํผ๋ฒ ๊ฐ๋ณด๋ค ํฐ ๊ฐ์ ๋ง๋ ๋ ๊น์ง
i++;
}
while(j>start && data[j] >= data[key]){ // ํค ๊ฐ๋ณด๋ค ์์ ๊ฐ์ ๋ง๋ ๋๊น์ง
j--;
}
if(i>j){ //์๊ฐ๋ฆฐ ์ํ๋ฉด ํผ๋ฒ ๊ฐ๊ณผ ๊ต์ฒด
temp = data[j];
data[j] = data[key];
data[key] = temp;
}
else{ //์๊ฐ๋ฆฌ์ง ์์ ์ํ๋ฉด i,j๋ฅผ ๊ต์ฒด
temp = data[j];
data[j] = data[i];
data[i] = temp;
}
}
quickSort(data,start,j-1);
quickSort(data,j+1,end);
}
int main(void){
quickSort(data, 0, number-1);
show();
return 0;
}
ํต์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ๊ทํจ์๋ฅผ ํตํด ๊ตฌํ๋๋ฉฐ, ๊ธฐ๋ณธ์ ์ผ๋ก N๋ฒ์ฉ ํ์ํ๋ ๋ฐ์ผ๋ก ์ชผ๊ฐ ๋ค์ด๊ฐ๋ค๋ ์ ์์ log N์ ๊ณฑํ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค. ํต ์ ๋ ฌ์ ํ๊ท ์๊ฐ ๋ณต์ก๋๋ O(N*logN)์ด์ง๋ง, ์ต์ ์๊ฐ ๋ณต์ก๋๋ O(N^2)์ด๋ค.
์ ๋ ฌ์ด ๋์ด์๋ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด๋ณด์.
๋ค์์ ์ซ์๋ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.
1 2 3 4 5 6 7 8 9 10
์์ ๊ฐ์ด ์ด๋ฏธ ์ ๋ ฌ์ด ์๋ฃ๋ ๊ฒฝ์ฐ ํต์ ๋ ฌ์ ์๊ฐ ๋ณต์ก๋๋ O(N^2)์ ๊ฐ๊น๋ค. ํ์ง๋ง ์ด์ ์ ๋ค๋ฃฌ ์ฝ์ ์ ๋ ฌ์ ์ฌ์ฉํ๋ฉด ๊ต์ฅํ ๋น ๋ฅด๊ฒ ๋ฌธ์ ๋ฅผ ํ ์ ์๋ค. ์ฆ ์ ๋ ฌํ ๋ฐ์ดํฐ์ ํน์ฑ์ ๋ฐ๋ผ ์ ์ ํ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ค์ํ๋ค.
ํ์ด์ฌ
def quicksort(data,start,end): #start๋ ๋ถํ ๋ ์งํฉ์ ์ฒซ๋ฒ์งธ ๊ฐ, end๋ ๋ถํ ๋ ์งํฉ์ ๋ง์ง๋ง ๊ฐ
if start >= end: #์์๊ฐ 1๊ฐ์ธ ๊ฒฝ์ฐ
return
key = start # ํผ๋ฒ ๊ฐ์ ์ฒซ๋ฒ์งธ ์์
i = start +1
j = end
while ( i<= j): #์๊ฐ๋ฆด ๋ ๊น์ง ๋ฐ๋ด
while i<=end and data[i] <= data[key] : # i๊ฐ ์ค๋ฅธ์ชฝ ๊ฐ๋ณด๋ค ์๋ค๋ฉด
i+=1
while(data[j]>= data[key] and j>start): # j๊ฐ ์ผ์ชฝ๋ณด๋ค ํฌ๋ค๋ฉด
j -=1
if i>j: #ํ์ฌ ์๊ฐ๋ฆฐ ์ํ๋ฉด
temp = data[j]
data[j] = data[key]
data[key] = temp
else:
temp = data[j]
data[j] = data[i]
data[i] = temp
quicksort(data,start,j-1)
quicksort(data,j+1,end)
a = [1,10,5,8,7,6,4,3,2,9]
quicksort(a,0,len(a)-1)
a
์ด ๊ธ์ ๋๋๋น๋์ ์ค์ ์๊ณ ๋ฆฌ์ฆ ๊ฐ์ข (Algorithm Programming Tutorial)๋ฅผ ์ฐธ๊ณ ํด ์์ฑํ์์ต๋๋ค.
https://www.youtube.com/watch?v=qQ5iLNjpxSk&list=PLRx0vPvlEmdDHxCvAQS1_6XV4deOwfVrz