Quick Sort(ํต ์ ๋ ฌ) ์๊ณ ๋ฆฌ์ฆ
Table of contents
์ด๋ฏธ ์ ๋ ฌ์ด ๋ง์ด ๋์ด์๋ ์ํ์์๋, ์๊ฐ๋ณต์ก๋๊ฐ ์ปค์ง ์ ์์ง๋ง, ์ผ๋ฐ์ ์ผ๋ก ๊ฐ์ฅ ๋น ๋ฅธ ์ ๋ ฌ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
๊ฐ๋จํ๊ฒ ์ค๋ช
ํ๋ฉด, ๊ธฐ์ค ๊ฐ์ ํ๋ ์ ํ๊ณ , start index
0
์์๋ถํฐ ๊ธฐ์ค๊ฐ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ ๋ฐ๊ฒฌํ๊ณ , end index
๋์์๋ถํฐ ๊ธฐ์ค๊ฐ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๊ฐ์ ๋ฐ๊ฒฌํ ์, ๋์์ ์์น๋ฅผ ๊ตํํ๊ณ , start ์ธ๋ฑ์ค๋ +1 end ์ธ๋ฑ์ค๋ -1์ ํ๊ณ ,
start index
์ end index
๊ฐ ๋ง๋ ๋ ๊น์ง ๊ตํ์ ์ํํ๊ณ , ๋ฃจํ๊ฐ ๋๋ ๋ค start index
์ ์์น๋ฅผ ๊ธฐ์ค์ผ๋ก ๊ณต๊ฐ์ ๋ถ๋ฆฌํ์ฌ ๋ ์์๊ฐ์ ๋ฃจํ๋ฅผ ๋ฐ๋ณตํ๋ฉด ์ต์ข
์ ์ผ๋ก ์ ๋ ฌ๋ ๋ฐฐ์ด์ด ๋์ค๊ฒ ๋๋ค.
์์
[5] 3 8 (9) 2 4 {7}
( [ ] = ์์์ธ๋ฑ์ค ( ) = ๊ธฐ์ค๊ฐ { } = ๋ ์ธ๋ฑ์ค )
์์ ์ธ๋ฑ์ค 5, ๊ธฐ์ค๊ฐ 9 ๋ ์ธ๋ฑ์ค 7 ์ธ ๋ฐฐ์ด์ด ์์ ๋
5 3 8 [(9)] 2 4 {7}
์์ ์ธ๋ฑ์ค๋ ๊ธฐ์ค๊ฐ๊ณผ ๊ฐ์ด ๊ฐ์ 9์์ ๋ฉ์ถค, ๋ ์ธ๋ฑ์ค๋ ๊ธฐ์ค๊ฐ๋ณด๋ค ์์ 7์์ ๋ฉ์ถค, ๋ ์๋ฅผ ๊ตํ
๊ธฐ์ค ๊ฐ์ 7๋ก ๋ฐ๋ ๊ฒ์ด๋ค.
5 3 8 (7) 2 {4} [9]
์์ ์ธ๋ฑ์ค๋ 7๋ณด๋ค ๊ทธ๊ฑฐ๋ ๊ฐ์ ๊ฐ์ ๋ฐ๊ฒฌํ์ง ๋ชปํด ๊ฒฐ๊ตญ 9๊น์ง ์๊ณ , ๋ ์ธ๋ฑ์ค๋ 7๋ณด๋ค ์์ 4๋ฅผ ๋ฐ๊ฒฌํ์ง๋ง, ์ด๋ฏธ ์์ ์ธ๋ฑ์ค์ ๋ ์ธ๋ฑ์ค๊ฐ ๋ง๋ ๊ต์ฐจํ ๋ค ๋ฐ๊ฒฌํ์ผ๋ฏ๋ก ๊ตํ์ ์ํํ์ง ์์
์์ ์ธ๋ฑ์ค์ ์์น๋ฅผ ๊ธฐ์ค์ผ๋ก ๊ณต๊ฐ์ ๋ถ๋ฆฌํ๋ค.
[5] 3 (8) 7 2 {4} || 9
9๋ ๊ฐ์ด 1๊ฐ์ด๋ฏ๋ก ์ ๋ ฌ์ ์ํํ ํ์๊ฐ ์๋ค.
5 3 [(8)] 7 2 {4} || 9
์ ๊ฒฝ์ฐ๋ ๊ธฐ์ค๊ฐ 8๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ ๊ฐ์ ๋ฐ๊ฒฌํ์ง ๋ชปํด ์์ ์ธ๋ฑ์ค๊ฐ 8๊น์ง ๋๋ฌํ๊ณ ๋์ธ๋ฑ์ค๋ 4๊ฐ ๊ธฐ์ค๊ฐ 8๋ณด๋ค ์์ผ๋ฏ๋ก 4๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์๋ค. ๋ ์์น๋ฅผ ๊ตํํ๋ค.
5 3 (4) [7] {2} 8 || 9
์์ ์ธ๋ฑ์ค๋ ๊ธฐ์ค๊ฐ 4๋ณด๋ค ํฐ 7์ ๋ฐ๊ฒฌํ๊ณ , ๋ ์ธ๋ฑ์ค๋ ๊ธฐ์ค๊ฐ 4๋ณด๋ค ์์ 2๋ฅผ ๋ฐ๊ฒฌํ๋ค. ๋ํ ๋ ์ธ๋ฑ์ค๊ฐ ๋ง๋๊ธฐ ์ด์ ์ด๋ฏ๋ก ๊ตํ์ ์ํํ๋ค.
5 3 (4) {2} [7] 8 || 9
๋๋ฒ์งธ ๋ฃจํ๊ฐ ์ง๋๋ค์๋ ์์ ๊ฐ์ ํํ๊ฐ ๋๊ณ , ์์ ์ธ๋ฑ์ค์ ์์น์ธ 7์ ๊ธฐ์ค์ผ๋ก ๊ณต๊ฐ์ ๋ ๋ถ๋ฆฌํ๋ค.
[5] (3) 4 {2} || [(7)] {8} || 9
์์ ๊ฐ์ ๊ฒฝ์ฐ๋, ์ง๊ธ๊น์ง ์ฌ์ฉํ๋ ๋ฃจํ ๋ฉ์ปค๋์ฆ์ ์ ์ฉํ๋ฉด
์ฒซ๋ฒ์งธ ๊ณต๊ฐ์ ๊ฒฝ์ฐ ๊ธฐ์ค๊ฐ 3๋ณด๋ค ํฐ 5์ ๊ธฐ์ค๊ฐ 3๋ณด๋ค ์์ 2๋ฅผ ๊ตํํ๊ณ ๋๋ฉด, ์์์ธ๋ฑ์ค์ ๋ ์ธ๋ฑ์ค๋ 3์ผ๋ก ๋ชจ์ด๊ฒ ๋๋ค.
๋๋ฒ์งธ ๊ณต๊ฐ์ ๊ฒฝ์ฐ ์ญ์, ๊ธฐ์ค๊ฐ 7๋ก ์์์ธ๋ฑ์ค์ ๋ ์ธ๋ฑ์ค๊ฐ ๋ชจ์ด๊ฒ ๋๋ค.
2 {[(3)]} 4 5 || {[(7)]} 8 || 9
์ต์ข ๊ฒฐ๊ณผ๋ ์์ ๊ฐ์ ๊ฒ์ด๊ณ , ์ ๋ ฌ์ด ๋์ด์์์ ํ์ธํ ์ ์๋ค.
๋๋คํ ๋ฐฐ์ด๋ก, ํ๋ฒ ๋จ๊ณ๋ณ๋ก ๊ทธ๋ ค๋ณด๋ฉด ์ดํด๊ฐ ์ฌ์ธ ๊ฒ์ด๋ค.
์ฝ๋
static void quickSort(int [] arr){
quickSort(arr, 0, arr.length-1); //์ด๊ธฐ start ์ end ๋ 0๊ณผ arr.length-1 ์ด๋ฏ๋ก, ๋ง๋ ๋ฉ์๋, ์ฌ์ค ์์ด๋ ๋๋ ๋ฉ์๋์ด๊ธด ํ๋ค.
}
static void quickSort(int [] arr, int start, int end){
int dividePoint = getDividePoint(arr, start , end);
if(start<dividePoint-1){ //start๊ฐ dividePoint-1 ๋ณด๋ค ์๋ค๋ ์๋ฏธ๋, ์ถฉ๋ถํ ๊ตํํ ์์๊ฐ ๋ค ์์ด์ก๋ค๋ ๋ป์ด๋ฏ๋ก, ์ ๋ ฌ์ด ๋๋ ์ํ
quickSort(arr,start,dividePoint-1);
}
if(end>dividePoint){
quickSort(arr,dividePoint,end);
}
}
๋จผ์ ์คํ๋๋ ๊ตฌ๋ฌธ์ ์์ ๊ฐ๋ค.
pivotPoint
๋ ์ด๊ธฐ๊ฐ์ ๋ฐฐ์ด์ ์ค๊ฐ ์ง์ ์ผ๋ก ์ค์ ํ ๊ฒ์ด๊ณ , ์ฒซ ๋ฃจํ๊ฐ ๋๋๋ฉด, ์ด๋์ด ๋๋ start index
๋ฅผ pivotPoint
๋ก ์ค์ ํ ๊ฒ์ด๊ธฐ ๋๋ฌธ์
์กฐ๊ฑด๋ฌธ์ ์์ ๊ฐ์ด ์์ฑํ๋ค.
์ด์ getPivotPoint
๋ฅผ ๊ตฌํํด์ผํ๋ค.
static int getDividePoint(int [] arr , int start , int end){
int Pivot = arr[(start+end)/2]; //ํผ๋ฒํฌ์ธํธ๋ ํญ์ ๊ตฌ๋ถ๋๋ ๋ฐฐ์ด์ ์ค๊ฐ๊ฐ์ผ๋ก
while(start<=end){ //start ๊ฐ end๋ณด๋ค ๋ค์ ์์ ๋๋ง ๊ตํ ์ํํด์ผํจ
while(arr[start]<Pivot){ //pivot์ ์์ชฝ์ ์์ ๊ฒฝ์ฐ๋ ์ธ๋ฑ์ค ์ฆ๊ฐ
start++;
}
while(arr[end]>Pivot){
end--;
}
if(start<=end){ //ํ๋ฒ ๋ ์ฒดํฌ
swap(arr,start,end); // ๊ตํ ํ ์ธ๋ฑ์ค ์ด๋์ ์ ์ง์์ผ์ผํจ
start++;
end--;
}
}
return start; //๋ฃจํ๊ฐ ๋ค ๋๋๊ณ ๋๋ฉด, start๋ end์ธ๋ฑ์ค์ ์ค๋ฅธ์ชฝ์ผ๋ก ๋์ด๊ฐ ์ํ๊ฐ ๋๊ณ , ์ด startํฌ์ธํธ๋ฅผ divide(๋ถ๋ฆฌ) ํฌ์ธํธ๋ก ์ ๊ณต
}
์ด์ swap
๋ฉ์๋๋ง ๊ตฌํํ๋ฉด ๋๋๋ฐ, swap
๋ฉ์๋ ๊ตฌํ์ ๋๋ฌด ๊ฐ๋จํ๋ ์๋ตํ๊ฒ ๋ค.
์์ฑ ์ฝ๋
class QuickSort {
static void quickSort(int [] arr){
quickSort(arr, 0, arr.length-1); //์ด๊ธฐ start ์ end ๋ 0๊ณผ arr.length-1 ์ด๋ฏ๋ก, ๋ง๋ ๋ฉ์๋, ์ฌ์ค ์์ด๋ ๋๋ ๋ฉ์๋์ด๊ธด ํ๋ค.
}
static void quickSort(int [] arr, int start, int end){
int dividePoint = getDividePoint(arr, start , end);
if(start<dividePoint-1){ //start๊ฐ dividePoint-1 ๋ณด๋ค ์๋ค๋ ์๋ฏธ๋, ์ถฉ๋ถํ ๊ตํํ ์์๊ฐ ๋ค ์์ด์ก๋ค๋ ๋ป์ด๋ฏ๋ก, ์ ๋ ฌ์ด ๋๋ ์ํ
quickSort(arr,start,dividePoint-1);
}
if(end>dividePoint){
quickSort(arr,dividePoint,end);
}
}
static int getDividePoint(int [] arr , int start , int end){
int Pivot = arr[(start+end)/2]; //ํผ๋ฒํฌ์ธํธ๋ ํญ์ ๊ตฌ๋ถ๋๋ ๋ฐฐ์ด์ ์ค๊ฐ๊ฐ์ผ๋ก
while(start<=end){ //start ๊ฐ end๋ณด๋ค ๋ค์ ์์ ๋๋ง ๊ตํ ์ํํด์ผํจ
while(arr[start]<Pivot){ //pivot์ ์์ชฝ์ ์์ ๊ฒฝ์ฐ๋ ์ธ๋ฑ์ค ์ฆ๊ฐ
start++;
}
while(arr[end]>Pivot){
end--;
}
if(start<=end){ //ํ๋ฒ ๋ ์ฒดํฌ
swap(arr,start,end); // ๊ตํ ํ ์ธ๋ฑ์ค ์ด๋์ ์ ์ง์์ผ์ผํจ
start++;
end--;
}
}
return start; //๋ฃจํ๊ฐ ๋ค ๋๋๊ณ ๋๋ฉด, start๋ end์ธ๋ฑ์ค์ ์ค๋ฅธ์ชฝ์ผ๋ก ๋์ด๊ฐ ์ํ๊ฐ ๋๊ณ , ์ด startํฌ์ธํธ๋ฅผ divide(๋ถ๋ฆฌ) ํฌ์ธํธ๋ก ์ ๊ณต
}
static void swap(int[] arr, int start, int end) {
int tmp = arr[start];
arr[start] = arr[end];
arr[end]=tmp;
}
}
์๊ฐ ์ ํ์ด ๊น๋ค๋ก์ด ์ ๋ ฌ ๋ฌธ์ ์ ๊ฒฝ์ฐ ํต ์ ๋ ฌ์ ์ ๊ทน ํ์ฉํด๋ด์ผ๊ฒ ๋ค.