자료구조 정렬 알고리즘을 간단히 구현

사실 간단하게 짠 것이라고 보기에느 코드가 좀 길지만
자료구조에서 정렬 알고리즘을 보고 입각해서 내용에 맞게 구현을 해 보았다

• 요점은 비교와 위치 교환의 개념으로
  배열에서 자기 바로 옆을 비교하는 것과
  열을 하나 지정해서 하나씩 비교해서 정렬하는 방식이고
  우선 버블 정렬과 선택 정렬만 구현해 보았다

• 셀 정렬이라던지 이진 정렬은 앞으로 구현 예정이다

소스코드

package DataStruct;

public class sortSample {
	
	public int [] sortedArray = new int[6]; //6,9,8,3,4,5 예시
	
	// 배열을 받아옴
	public void getSample(int[] arr) {		
		sortedArray = arr;
		System.out.println("[정렬 전 배열]");
		System.out.println("현재 : " + rtnSortArray()); // 정렬 전 배열
		System.out.println("------------------------------------------------------");
		
	}

	// 버블 정렬
	public void BubbleSort() {
		
		System.out.println("[1. 버블 정렬]");
		int a = 0;
		int b = 0;
		int c = 0; //배열 갯수 만큼 비교해서 변경할 대상이 없을 때 빠져나가도록
		
		for(int i = 0; i < sortedArray.length; i++ ) {
						
			c = 0;
			System.out.println( i + 1 + "차");				
			for(int j = 0; j < sortedArray.length-1; j++ ) {

				a = sortedArray[j];
				b = sortedArray[j+1];
								
				if(a > b) {
					System.out.println(">>> (" + (j+ 1) + ") 단계");
					System.out.println("현재 위치 값 : " + a);
					System.out.println("다음 위치 값 : " + b);

					System.out.println(a + " 가 " + b + " 보다 크므로   [" + (j + 1) + "] 열 과 : [" + j + "] 열  서로 이동");					
					System.out.println("위치 : " + "[0],[1],[2],[3],[4],[5]"); // 열 위치 참고용
					System.out.println("이전 : " + rtnSortArray());
					sortedArray[j] = b;
					sortedArray[j+1] = a;

					System.out.println("현재 : " + rtnSortArray());
				} else {
					System.out.println(">>> (" + (j+ 1) + ") 단계");
					System.out.println(a + " 가 " + b + " 보다 작으므로   [" + j + "] 열 과 : [" + (j + 1) + "] 열  이동 하지 않음");
					
					c = c +1;
					// 배열 갯수 만큼 비교해서 더 이상 변경할 대상이 없을 경우에는 더 이상 처리하지 않음 
					if(c == sortedArray.length-1) {
						System.out.println("더 이상 정렬할 대상이 없음. \r실행 종료");
						System.out.println("------------------------------------------------------");
						return;
					} else {
						System.out.println("현재 : " + rtnSortArray());
					}
					
				} 
			}
			System.out.println("------------------------------------------------------");
		}
		
	}
	// 선택 정렬
	public void SelectSort() {
	
		System.out.println("[2. 선택 정렬]");
		int a = 0;
		int b = 0;
		int c = 0;
		int d = 0; //배열 갯수 만큼 비교해서 변경할 대상이 없을 때 빠져나가도록
		
		for(int i = 0; i < sortedArray.length; i ++) {
			
			System.out.println( i + 1 + "차");
			a = sortedArray[i];

			System.out.println("["+ i +"] 열 : " + a);
			
			for(int j = i+1; j < sortedArray.length; j ++) {
				b = sortedArray[j];

				System.out.println("[" + j + "] 열 : 값 = " + b);
				
				if(a > b) {					
					c = j; // 스욉할 대상의 배열 위치 기억
					a = b;
				}
				
			}
			System.out.println("현재 위치 값 = [" + i + "]열 : 값 = " + sortedArray[i]);
			System.out.println("최소 값 = [" + c + "]열 : 값  = " + a);


			
			if(i < sortedArray.length - 1){
				if(sortedArray[i] != a) {
					
					System.out.println("["+ i +"] 열과 ["+ c +"] 열의 자리 변경");
					System.out.println("위치 : " + "[0],[1],[2],[3],[4],[5]"); // 열 위치 참고용
					
					System.out.println("이전 : "+ rtnSortArray());				
					sortedArray[c] = sortedArray[i];
					sortedArray[i] = a;	
					System.out.println("현재 : "+ rtnSortArray());
				}
			} else {
				// 선택 정렬 가장 마지막 단계에서 전체를 한번 더 검색하는 단계
				for(int k = 0; k < sortedArray.length -1; k++) {
					
					if(sortedArray[k] > sortedArray[i]) {
						System.out.println("현재 위치 값 = " + sortedArray[i]);
						System.out.println("최대 값 = " + sortedArray[k]);
						b = sortedArray[k]; // 최대 값 기억
						a = sortedArray[i]; // 스왑 할 값 기억
						
						System.out.println("["+ i +"] 열과 ["+ c +"] 열의 자리 변경");
						System.out.println("위치 : " + "[0],[1],[2],[3],[4],[5]"); // 열 위치 참고용
						
						System.out.println("이전 : "+ rtnSortArray());						
						sortedArray[i] = b;
						sortedArray[k] = a;
						System.out.println("현재 : "+ rtnSortArray());

					}
					
					d = d +1;
					
					// 배열 갯수 만큼 비교해서 더 이상 변경할 대상이 없을 경우에는 더 이상 처리하지 않음 
					if(d == sortedArray.length -1 ) {
						System.out.println("더 이상 정렬할 대상이 없음. \r실행 종료");
					}
				}
				

			}
			
			System.out.println("------------------------------------------------------");
		}
		
	}
	// 이진 정렬
	public void BinarySort() {
		
	}
	
	// 배열의 내용을 표시함
	public String rtnSortArray(){
		String rtn = ""; 
		
		for(int i =0; i < sortedArray.length; i++) {
			
			if(i < sortedArray.length-1) {
				rtn += "["+ sortedArray[i] + "],";
			} else {
				rtn += "["+ sortedArray[i] + "]";
			}
			
		}
		
		return rtn;
		
	}
	
}

출력물

[1. 버블 정렬]
[정렬 전 배열]
현재 : [6],[9],[8],[3],[4],[5]
------------------------------------------------------
1차
>>> (1) 단계
6 가 9 보다 작으므로   [0] 열 과 : [1] 열  이동 하지 않음
현재 : [6],[9],[8],[3],[4],[5]
>>> (2) 단계
현재 위치 값 : 9
다음 위치 값 : 8
9 가 8 보다 크므로   [2] 열 과 : [1] 열  서로 이동
위치 : [0],[1],[2],[3],[4],[5]
이전 : [6],[9],[8],[3],[4],[5]
현재 : [6],[8],[9],[3],[4],[5]
>>> (3) 단계
현재 위치 값 : 9
다음 위치 값 : 3
9 가 3 보다 크므로   [3] 열 과 : [2] 열  서로 이동
위치 : [0],[1],[2],[3],[4],[5]
이전 : [6],[8],[9],[3],[4],[5]
현재 : [6],[8],[3],[9],[4],[5]
>>> (4) 단계
현재 위치 값 : 9
다음 위치 값 : 4
9 가 4 보다 크므로   [4] 열 과 : [3] 열  서로 이동
위치 : [0],[1],[2],[3],[4],[5]
이전 : [6],[8],[3],[9],[4],[5]
현재 : [6],[8],[3],[4],[9],[5]
>>> (5) 단계
현재 위치 값 : 9
다음 위치 값 : 5
9 가 5 보다 크므로   [5] 열 과 : [4] 열  서로 이동
위치 : [0],[1],[2],[3],[4],[5]
이전 : [6],[8],[3],[4],[9],[5]
현재 : [6],[8],[3],[4],[5],[9]
------------------------------------------------------
2차
>>> (1) 단계
6 가 8 보다 작으므로   [0] 열 과 : [1] 열  이동 하지 않음
현재 : [6],[8],[3],[4],[5],[9]
>>> (2) 단계
현재 위치 값 : 8
다음 위치 값 : 3
8 가 3 보다 크므로   [2] 열 과 : [1] 열  서로 이동
위치 : [0],[1],[2],[3],[4],[5]
이전 : [6],[8],[3],[4],[5],[9]
현재 : [6],[3],[8],[4],[5],[9]
>>> (3) 단계
현재 위치 값 : 8
다음 위치 값 : 4
8 가 4 보다 크므로   [3] 열 과 : [2] 열  서로 이동
위치 : [0],[1],[2],[3],[4],[5]
이전 : [6],[3],[8],[4],[5],[9]
현재 : [6],[3],[4],[8],[5],[9]
>>> (4) 단계
현재 위치 값 : 8
다음 위치 값 : 5
8 가 5 보다 크므로   [4] 열 과 : [3] 열  서로 이동
위치 : [0],[1],[2],[3],[4],[5]
이전 : [6],[3],[4],[8],[5],[9]
현재 : [6],[3],[4],[5],[8],[9]
>>> (5) 단계
8 가 9 보다 작으므로   [4] 열 과 : [5] 열  이동 하지 않음
현재 : [6],[3],[4],[5],[8],[9]
------------------------------------------------------
3차
>>> (1) 단계
현재 위치 값 : 6
다음 위치 값 : 3
6 가 3 보다 크므로   [1] 열 과 : [0] 열  서로 이동
위치 : [0],[1],[2],[3],[4],[5]
이전 : [6],[3],[4],[5],[8],[9]
현재 : [3],[6],[4],[5],[8],[9]
>>> (2) 단계
현재 위치 값 : 6
다음 위치 값 : 4
6 가 4 보다 크므로   [2] 열 과 : [1] 열  서로 이동
위치 : [0],[1],[2],[3],[4],[5]
이전 : [3],[6],[4],[5],[8],[9]
현재 : [3],[4],[6],[5],[8],[9]
>>> (3) 단계
현재 위치 값 : 6
다음 위치 값 : 5
6 가 5 보다 크므로   [3] 열 과 : [2] 열  서로 이동
위치 : [0],[1],[2],[3],[4],[5]
이전 : [3],[4],[6],[5],[8],[9]
현재 : [3],[4],[5],[6],[8],[9]
>>> (4) 단계
6 가 8 보다 작으므로   [3] 열 과 : [4] 열  이동 하지 않음
현재 : [3],[4],[5],[6],[8],[9]
>>> (5) 단계
8 가 9 보다 작으므로   [4] 열 과 : [5] 열  이동 하지 않음
현재 : [3],[4],[5],[6],[8],[9]
------------------------------------------------------
4차
>>> (1) 단계
3 가 4 보다 작으므로   [0] 열 과 : [1] 열  이동 하지 않음
현재 : [3],[4],[5],[6],[8],[9]
>>> (2) 단계
4 가 5 보다 작으므로   [1] 열 과 : [2] 열  이동 하지 않음
현재 : [3],[4],[5],[6],[8],[9]
>>> (3) 단계
5 가 6 보다 작으므로   [2] 열 과 : [3] 열  이동 하지 않음
현재 : [3],[4],[5],[6],[8],[9]
>>> (4) 단계
6 가 8 보다 작으므로   [3] 열 과 : [4] 열  이동 하지 않음
현재 : [3],[4],[5],[6],[8],[9]
>>> (5) 단계
8 가 9 보다 작으므로   [4] 열 과 : [5] 열  이동 하지 않음
더 이상 정렬할 대상이 없음. 
실행 종료
------------------------------------------------------


[2. 선택 정렬]
[정렬 전 배열]
현재 : [11],[20],[18],[3],[7],[15]
------------------------------------------------------
1차
[0] 열 : 11
[1] 열 : 값 = 20
[2] 열 : 값 = 18
[3] 열 : 값 = 3
[4] 열 : 값 = 7
[5] 열 : 값 = 15
현재 위치 값 = [0]열 : 값 = 11
최소 값 = [3]열 : 값  = 3
[0] 열과 [3] 열의 자리 변경
위치 : [0],[1],[2],[3],[4],[5]
이전 : [11],[20],[18],[3],[7],[15]
현재 : [3],[20],[18],[11],[7],[15]
------------------------------------------------------
2차
[1] 열 : 20
[2] 열 : 값 = 18
[3] 열 : 값 = 11
[4] 열 : 값 = 7
[5] 열 : 값 = 15
현재 위치 값 = [1]열 : 값 = 20
최소 값 = [4]열 : 값  = 7
[1] 열과 [4] 열의 자리 변경
위치 : [0],[1],[2],[3],[4],[5]
이전 : [3],[20],[18],[11],[7],[15]
현재 : [3],[7],[18],[11],[20],[15]
------------------------------------------------------
3차
[2] 열 : 18
[3] 열 : 값 = 11
[4] 열 : 값 = 20
[5] 열 : 값 = 15
현재 위치 값 = [2]열 : 값 = 18
최소 값 = [3]열 : 값  = 11
[2] 열과 [3] 열의 자리 변경
위치 : [0],[1],[2],[3],[4],[5]
이전 : [3],[7],[18],[11],[20],[15]
현재 : [3],[7],[11],[18],[20],[15]
------------------------------------------------------
4차
[3] 열 : 18
[4] 열 : 값 = 20
[5] 열 : 값 = 15
현재 위치 값 = [3]열 : 값 = 18
최소 값 = [5]열 : 값  = 15
[3] 열과 [5] 열의 자리 변경
위치 : [0],[1],[2],[3],[4],[5]
이전 : [3],[7],[11],[18],[20],[15]
현재 : [3],[7],[11],[15],[20],[18]
------------------------------------------------------
5차
[4] 열 : 20
[5] 열 : 값 = 18
현재 위치 값 = [4]열 : 값 = 20
최소 값 = [5]열 : 값  = 18
[4] 열과 [5] 열의 자리 변경
위치 : [0],[1],[2],[3],[4],[5]
이전 : [3],[7],[11],[15],[20],[18]
현재 : [3],[7],[11],[15],[18],[20]
------------------------------------------------------
6차
[5] 열 : 20
현재 위치 값 = [5]열 : 값 = 20
최소 값 = [5]열 : 값  = 20
더 이상 정렬할 대상이 없음. 
실행 종료
------------------------------------------------------