선택 정렬(Selection Sort)는 배열의 원소 중에서 원하는 위치에 놓을 데이터를 찾아 선택하는 것

 

어떤 배열을 오름차순으로 정렬하고 싶다고 가정하고 설명하도록 한다.

int[] array = {5, 9, 1, 7, 2}; 인 배열 array가 있다고 하자.

정렬을 할 때마다 배열의 맨 앞부터의 위치들에 최솟값들이 하나씩 이동하게 되므로

이미 최솟값을 이동시킨 위치는 고려하지 않고, 그 다음 위치들 중에서 최솟값을 찾는다.

 

즉, 전체적인 과정을 설명하면,

 

1. 배열의 각 원소 중에서 최솟값을 찾고, 이를 array[0]과 자리를 바꾼다. (swap)

2. array[0]을 제외한 나머지 원소들 중에서 최솟값을 찾아 array[1]과 자리를 바꾼다.

3. array[2], array[3]....도 위의 방법대로 반복한다.

 

이때, (배열의 길이 - 1)만큼만 최솟값을 찾는 cycle을 진행하면 되는데, 

위의 예시에서 총 5개의 데이터 중에서 4개의 데이터를 정렬했다는 것은 이미 마지막 데이터는 정렬이 되었다는 의미이기 때문이다. (최솟값을 찾고 나머지 값들과 비교하여 정렬했으므로 2개씩 비교가 되었기 때문) 

 

이를 코드를 작성하여 비교해보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Arrays;
 
public class Selection_Sort {
    public static void main(String[] args) {
        // 선택정렬을 통해 오름차순으로 정렬
        int[] array = { 59172 };
        // 최솟값을 갖는 index를 찾아 그 index 자리의 값과 array[i]값을 바꿔준다.
        for (int i = 0; i < array.length - 1; i++) {
            int minIdx = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[minIdx] > array[j]) {
                    minIdx = j;
                }
            }
            int tmp = array[i];
            array[i] = array[minIdx];
            array[minIdx] = tmp;
        
        }
        System.out.println(Arrays.toString(array));
    }
}
 
cs

내림차순도 같은 논의로 진행해보면, (부등호의 방향만 반대)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Arrays;
 
public class Selection_Sort {
    public static void main(String[] args) {
        // 선택정렬을 통해 내림차순으로 정렬
        int[] array = { 59172 };
        // 최댓값을 갖는 index를 찾아 그 index 자리의 값과 array[i]값을 바꿔준다.
        for (int i = 0; i < array.length - 1; i++) {
            int maxIdx = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[maxIdx] < array[j]) {
                    maxIdx = j;
                }
            }
            int tmp = array[i];
            array[i] = array[maxIdx];
            array[maxIdx] = tmp;
        
        }
        System.out.println(Arrays.toString(array));
    }
}
 
cs

그 결과, {9, 7, 5, 2, 1}로 내림차순 정렬이 됨을 확인할 수 있다.

 

두 개의 인접한 원소(값)을 비교하여 정렬하는 것

버블 정렬에 대해 알아보기 위해 배열을 오름차순으로 나타내는 것을 기준으로 한다.

간단하게 말하면, 두개씩 값을 비교하고, 조건에 맞게 swap하는 것이다.

 

1. array[0]에서부터 비교(첫번째 cycle)

int[] array = { 1, 5, 9, 3, 7, 1, 0}; 인 배열 array을 오름차순으로 정렬하는 것을 예로 들어 설명하도록 한다.

먼저, array[0]과 array[1]을 비교했을 때, array[0] < array[1]이므로 swap할 필요가 없다.

같은 방식으로, array[1]와 array[2] 또한 swap할 필요가 없다.

이때, array[2] > array[3]이므로 두 원소를 swap해야 한다.

같은 방식으로 진행한 결과는 다음과 같다.

첫 번째 cycle 결과 배열 array는 { 1, 5, 3, 7, 1, 0, 9 }가 되었다.

 

2. 두번째 사이클

3. 세번째 사이클

4. 네번째 사이클

5. 다섯번째 사이클

6. 여섯번째 사이클

최종적으로 버블 정렬을 통해 오름차순 정렬을 한 결과는 {0, 1, 1, 3, 5, 7, 9}이다.

 

이제 코드를 작성하여 결과를 비교해보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Arrays;
 
public class test {
 
    public static void main(String[] args) {
        // 오름차순
        int[] array = { 1539710 };
        int tmp; // swap을 위한 변수 선언
        // cycle은 (배열의 크기-1)만큼 진행된다.
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    tmp = array[j + 1];
                    array[j + 1= array[j];
                    array[j] = tmp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
 
    }
 
}
 
cs

 

동일한 결과가 나타난다. 

 

내림차순으로 정렬하는 경우는 오름차순 정렬과 같은 논의이므로 부등호의 방향만 달리하면 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Arrays;
 
public class test {
 
    public static void main(String[] args) {
        // 내림차순
        int[] array = { 1539710 };
        int tmp; // swap을 위한 변수 선언
        // cycle은 (배열의 크기-1)만큼 진행된다.
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] < array[j + 1]) {
                    tmp = array[j + 1];
                    array[j + 1= array[j];
                    array[j] = tmp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
 
    }
 
}
 
cs

 

결과는 { 9, 7, 5, 3, 1, 1, 0}.

정렬 방법 중에서 오름차순과 내림차순에 대해서 알아보자.

 

int[] num = { 3, 6, 4, 8, 1} 를 오름차순으로 정렬

1. num[0] 값과 나머지 num[1] ~ num[4]의 값을 한 쌍씩 비교한다.

2. 이때, num[0] > num[i] (i = 1,2,3,4) 이면, 자리를 바꿔준다. 그 결과 배열 num은 { 1, 6, 4, 8, 3 }이 된다.

3. num[1] 값과 나머지 num[2] ~ num[4]의 값을 한 쌍씩 비교한다.

4. 이때, num[1] > num[i] (i = 2,3,4) 이면, 자리를 바꿔준다. 그 결과 배열 num은 { 1, 4, 6, 8, 3 } -> { 1, 3, 6, 8, 4 }가 된다.

5. num[2] 값과 나머지 num[3] , num[4]의 값을 한 쌍씩 비교한다.

6. 이때, num[2] > num[i] (i = 3,4) 이면, 자리를 바꿔준다. 그 결과 배열 num은 { 1, 3, 4, 8, 6 }이 된다.

7. num[3] 값과 num[4]의 값을 비교한다. 그 결과 최종적으로 배열 num이 { 1, 3, 4, 6, 8 }이 되었다.

 

내림차순의 경우는 부등호 방향을 반대로 하여 비교한다.

 

이제 직접 코드를 작성하여 결과를 비교해보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package test;
 
import java.util.Arrays;
 
public class Practice {
 
    public static void main(String[] args) {
        
        int[] num = {3,6,4,8,1};
        int temp;
        //오름차순
        for (int i = 0; i < num.length - 1; i++) {
            for(int j = i + 1; j < num.length; j++) {
                if(num[i] > num[j]) {
                    temp = num[i];   //swap
                    num[i] = num[j];
                    num[j] = temp;
                }
            }
        }
        
        System.out.print(Arrays.toString(num));
        
    }
    
 
}
 
cs

결과는 { 1, 3, 4, 6, 8 }이다.

 

같은 논리로 내림차순 정렬을 해보면,

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package test;
 
import java.util.Arrays;
 
public class Practice {
 
    public static void main(String[] args) {
        
        int[] num = {3,6,4,8,1};
        int temp;
        //내림차순
        for (int i = 0; i < num.length - 1; i++) {
            for(int j = i + 1; j < num.length; j++) {
                if(num[i] < num[j]) {
                    temp = num[i];   //swap
                    num[i] = num[j];
                    num[j] = temp;
                }
            }
        }
        
        System.out.print(Arrays.toString(num));
        
    }
    
 
}
 
cs

결과는 { 8, 6, 4, 3, 1 }이다.

 

 

'Java' 카테고리의 다른 글

파일(File)  (0) 2022.12.27
날짜와 시간(Calendar class)  (2) 2022.12.26
예외(Exception) 처리  (0) 2022.12.26
함수 사용  (4) 2022.12.26
break, continue  (0) 2022.12.23

+ Recent posts