2. 정렬 - 교환 클래스 정렬

더 읽 기
1. 거품 정렬
기본 사상
비교적 인접 한 원소.첫 번 째 가 두 번 째 보다 크 면 두 사람 을 교환 하 세 요
모든 인접 요소 에 대해 똑 같은 작업 을 하고 첫 번 째 쌍 부터 마지막 쌍 까지 한다.이 점 에서 마지막 요 소 는 가장 큰 숫자 일 것 이다
모든 요소 에 대해 이상 의 절 차 를 반복 합 니 다. 마지막 을 제외 하고..
한 쌍 의 숫자 를 비교 할 필요 가 없 을 때 까지 점점 적어 지 는 요소 에 대해 위의 절 차 를 반복 합 니 다
코드 는 다음 과 같 습 니 다:

package sort.exchange;


/**
 *       
 * 
 * @author king
 *
 */
public class BuddleSort {
	//  
	private static void buddleSort(int[] data){
		int count=1;
		for(int i=0;idata[j]){
					//      
					temp=data[j];
					data[j]=data[j-1];
					data[j-1]=temp;
				}
			}
			System.out.println(" " + count + "   :");
			for (int k = 0; k < data.length; k++) {
				System.out.print(data[k] + " ");
			}
			System.out.print("
");
			count++;
		}
	}
	public static void main(String[] args) {
		int[] data= new int[]{10,9,8,7,6,5,4,3,2,1};
		buddleSort(data);
		for (int k = 0; k < data.length; k++) {
			System.out.print(data[k] + " ");
		}
	}
}

실행 결과 
첫 번 째 정렬:
9 8 7 6 5 4 3 2 1 10 
두 번 째 정렬:
8 7 6 5 4 3 2 1 9 10 
세 번 째 정렬:
7 6 5 4 3 2 1 8 9 10 
4 번 째 정렬:
6 5 4 3 2 1 7 8 9 10 
다섯 번 째 정렬:
5 4 3 2 1 6 7 8 9 10 
여섯 번 째 정렬:
4 3 2 1 5 6 7 8 9 10 
7 번 째 정렬:
3 2 1 4 5 6 7 8 9 10 
8 번 째 정렬:
2 1 3 4 5 6 7 8 9 10 
9 번 째 정렬:
1 2 3 4 5 6 7 8 9 10 
열 번 째 정렬:
1 2 3 4 5 6 7 8 9 10 
 
개 선 된 거품 알고리즘?로고 교환 여부 exchange 추가
 
2. 빠 른 정렬
빠 른 정렬 (Quick Sort) 의 기본 사상 은 관건 적 인 코드 를 계속 비교 함으로써 특정한 기록 을 경계 (이 기록 을 지점 이 라 고 함) 로 하고 대기 서열 을 두 부분 으로 나 누 는 것 이다.그 중에서 일 부 는 모든 기록 을 만족 시 키 는 관건 적 인 코드 가 지점 기록 의 관건 적 인 코드 보다 크 거나 같 으 며 다른 부분 기록 의 관건 적 인 코드 는 지점 기록 의 관건 적 인 코드 보다 작다.지점 기록 을 경계 로 정렬 대기 열 을 관건 코드 에 따라 두 부분 으로 나 누 는 과정 을 일차 구분 이 라 고 한다.전체 서열 이 핵심 코드 에 따라 질서 가 있 을 때 까지 각 부분 을 계속 구분 합 니 다.
 
코드 는 다음 과 같 습 니 다. 왜 자꾸 코드 가 이상 하 다 고 생각 합 니까?

package sort.exchange;

/**
 *       
 * 
 * @author king
 */
public class QuickSort {
	
	private static int count = 1;
	//                       
	public static void quickSort(int[] data, int low, int high) {
		int i = low;
		int j = high;
		//      ,     
		int temp = data[low];
		while (low < high) {
			while (low < high && data[high] >= temp) {//    
				--high;
			}
			data[low] = data[high];
			if (low < high)
				low++;
			while (low < high && data[low] <= temp) {//    
				++low;
			}
			data[high] = data[low];
			if (low < high)
				--high;
		}
		data[low] = temp;//             
		System.out.println(" " + count + "   :");
		for (int k = 0; k < data.length; k++) {
			System.out.print(data[k] + " ");
		}
		count++;
		System.out.print("
");
		//              
		//                
		//                
		//               
		if (i < low - 1) {
			quickSort(data, i, low - 1);
		}
		if (low + 1 < j) {
			quickSort(data, low + 1, j);
		}
	}
	public static void main(String[] args) {
		int[] data = new int[]{10,9,8,7,11,5,4,3,2,1};
		quickSort(data, 0, data.length - 1);
	}
}

 실행 결과:
 
첫 번 째 정렬:
 
1 9 8 7 2 5 4 3 10 11 
 
두 번 째 정렬:
 
1 9 8 7 2 5 4 3 10 11 
 
세 번 째 정렬:
 
1 3 8 7 2 5 4 9 10 11 
 
4 번 째 정렬:
 
1 2 3 7 8 5 4 9 10 11 
 
다섯 번 째 정렬:
 
1 2 3 4 5 7 8 9 10 11 
 
여섯 번 째 정렬:
 
1 2 3 4 5 7 8 9 10 11