public class SEFix { 				// SEFix객체를 생성.
	public static void main(String[] args) { // 접근 한정자를 public으로 설정(어디서든지 사용가능)
							// static으로 메모리를 미리 할당
							// void는 함수가 끝날 때 리턴값이 없다.
							// main은 메인 함수로 쓰여지는것
							// String[] args는 args를 문자열로 사용하겠다 라는 의미
		int arr[] = { 5, 2, 1 }; 		// arr 이라는 배열이 가르키는 주소 메모리 값을 3으로 선언과 동시에 5,2,1로 초기화

		System.out.print("초기값 : ");			//초기값 출력문
		for(int i=0; i<3; i++){				//0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
		System.out.print(arr[i] + "    ");			//arr배열값 출력문
	}
		System.out.println();				//줄바꿈
		for (int j = 0; j < 4; j++) { 			// 0 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
			for (int i = 0; i < 3; i++) {	 		// 0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
				int cnt[] = { 0, 0, 0 };					// cnt라는 배열이 가르키는 주소 메모리 값을 3으로 선언과 동시에 0,0,0으로 초기화

				if (i == 0) { 							// i==0 일때 조건문 실행
					if (arr[0] != 0) {						//arr[0]이 0이 아닐때
						arr[0] = arr[0] - 1;				//arr[0] -1
						cnt[0] = cnt[0] + 1;				//cnt + 1
						System.out.print("현재값 : ");		//현재값 출력문
						for (int q = 0; q < 3; q++) {		// 0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
							if (arr[q] > 0) {				//arr[q]가 0보다 크다면 조건문 실행
								System.out.print(arr[q] + "(" + cnt[q] + ")");		//arr배열, cnt배열값 출력
							}
						}
						System.out.println();							//줄바꿈
					}
				} else if (i == 1) { 							// i==1 일때 조건문 실행
					if (arr[1] != 0) {						//arr[1]이 0이 아닐때 조건문 실행
						arr[1] = arr[1] - 1;					//arr[1] - 1
						cnt[1] = cnt[1] + 1;					//cnt[1] +1 
						System.out.print("현재값 : ");			//현재값 출력문
						for (int q = 0; q < 3; q++) {			// 0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
							if (arr[q] > 0) {				//arr[q]값이 0보다 크다면 조건문 실행
								System.out.print(arr[q] + "(" + cnt[q] + ")");		//arr배열, cnt배열값 출력
							}
						}
						System.out.println();
					}
				} else if (i == 2) { // i==2 일때 조건문 실행			//i==2 일때 조건문 실행
					if (arr[2] != 0) {						//arr[2]값이 0이 아니라면 조건문 실행
						arr[2] = arr[2] - 1;					//arr[2] - 1
						cnt[2] = cnt[2] + 1;					//cnt + 1
						System.out.print("현재값 : ");			//현재값 출력문
						for (int q = 0; q < 3; q++) {			// 0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
							if (arr[q] > 0) {				//arr[q]값이 0보다 크다면 조건문 실행
								System.out.print(arr[q] + "(" + cnt[q] + ")");		//arr배열, cnt배열값 출력
							}
						}
						System.out.println();				//줄바꿈
					}
				}
			}
		}
	}
}

import java.util.Scanner;       	//Scanner를 사용하기위해 import를 통해 외부 클래스를 호출
                			//Scanner는 java.util 패키지에 포함되어있다.

public class SJF                 //SJF객체를 생성.
{ 
   public static void main(String[] args) 	//접근 한정자를 public으로 설정(어디서든지 사용가능)
                   						//static으로 메모리를 미리 할당
                   						//void는 함수가 끝날 때 리턴값이 없다.
                   						//main은 메인 함수로 쓰여지는것
                   						//String[] args는 args를 문자열로 사용하겠다 라는 의미
   {
      int arr[]={0,0,0};                     						//arr 이라는 배열이 가르키는 주소 메모리 값을 3으로 선언과 동시에 0,0,0으로 초기화 
      Scanner sc = new Scanner(System.in);             			//객체를 생성 System.in은 키보드로 입력받기위해 사용
      int arr2=0;                        						//arr2라는 변수가 가르키는 주소값의 메모리안에 0으로 값을 초기화 /스캐너 클래스로 입력받을 변수
      int cnt3=0;                         						//cnt3라는 변수가 가르키는 주소값의 메모리안에 0으로 값을 초기화 /총 중복을 체크하기위한 변수
     
      System.out.println("\n----------START----------");      	//시작 출력문, 줄바꿈
      for(int i=0; i<5; i++)                   				//0 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
      {
         System.out.print("값을 입력해주세요: ");      	//값 입력 출력문
         arr2 = sc.nextInt();                  		//입력받은 정수를 변수 arr2라는 주솟값이 가르키는 메모리에 저장
         int notEmpty=0;                   		//공백을 알아보기위한 변수
                           					//notEmpty라는 변수가 가르키는 주소값의 메모리안에 0으로 값을 초기화
         int sameCount=0;                   		//중복을 알아보기위한 변수
                           					//sameCount라는 변수가 가르키는 주소값의 메모리안에 0으로 값을 초기화
         int temp=0;                   			//공백이 일어났을 시 공백의 인덱스 값을 받기위해 진행합니다.
                           					//temp라는 변수가 가르키는 주소값의 메모리안에 0으로 값을 초기화
         
       for(int j=0;j<arr.length;j++)             	//0 ~ arr배열 길이-1까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
       {
          if(arr[j]==0) {                   		//arr[j]값이 0 이라면 조건문 실행
             temp=j;                     		//조건이 true 라면 temp 값 j에 대입
             break;                     		//검사후 for문 탈출
          }
          else {
             cnt3++;                      	//조건문이 false면 cnt3값 증가
             notEmpty++;                   //조건문이 false면 notEmpty값 증가
          }   
       }
       for(int j=0;j<arr.length;j++)            	//0 ~ arr배열 길이-1까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
       {  
          if(arr[j]==arr2) {                   	//arr[j]와 arr2값이 같다면 조건문 실행
             sameCount++;                  	//sameCount값 증가
          }          
       }
       for(int j=0; j<arr.length; j++)           	//0 ~ arr배열 길이-1까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
       {
          if((sameCount==0)&& (j==arr.length-1)&&(notEmpty!=3)) {       	//중복이 존재하지 않을시 조건문 실행
             arr[temp]=arr2;                           					//arr[temp]값에 arr2 대입
          }
       }
       if((notEmpty==3)&&(sameCount==0))          //notEmpty==3은 공백이 없다는 뜻이고 sameCount==0이라는 것은 
                              					//공백이 없다는 것을 의미하기에 포화상태일 경우를 의미한다. true라면 조건문 실행
       {
          int temp2=0;                      	//변수 temp2를 0으로 초기화합니다.
          for(int j=0; j<arr.length-1; j++)      	//0 ~ arr배열 길이-1까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
          {
             
             for(int k=0; k<arr.length-1; k++)         //0 ~ arr배열 길이-1까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
              {
                 if(arr[k]>arr[k+1]) {               	//arr[k] > arr[k+1] 값이 true라면 조건문 실행
                    temp2 = arr[k];               	//temp2 값을 arr[k]에 대입
                    arr[k] = arr[k+1];            	//arr[k]값을 arr[k+1]에 대입
                    arr[k+1] = temp2;            	//arr[k+1]값을 temp2에 대입
                 }
              }
          }
          arr[0]=arr[1];               	//arr[0]값을 arr[1]에 대입
          arr[1]=arr[2];              		 //arr[1]값을 arr[2]에 대입
          arr[2]=arr2;                  	//arr2[]값을 arr2에 대입
         
          for(int j=0; j<arr.length-1; j++)         	//0 ~ arr배열 길이-1까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
          {
             
             for(int k=0; k<arr.length-1; k++)         	//0 ~ arr배열 길이-1까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
              {
                 if(arr[k]>arr[k+1]) {               	//arr[k] > arr[k+1] 값이 true라면 조건문 실행
                    temp2 = arr[k];               	//temp2 값을 arr[k]에 대입
                    arr[k] = arr[k+1];            	//arr[k]값을 arr[k+1]에 대입
                    arr[k+1] = temp2;            	//arr[k+1]값을 temp2에 대입
                 }
              }
          }
       }
      System.out.print(i+1+"번째, 현재 들어간 값: ");     	//현재 들어간 값 출력문
      for(int k=0;k<arr.length;k++) {            			//0 ~ arr배열 길이-1까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
         System.out.print(arr[k]+" ");             			//arr[k]값 출력문
      }
          System.out.println();               			//줄바꿈
      }
      System.out.println("----------END----------\n");
     }
  }

import java.util.Scanner;			//Scanner를 사용하기위해 import를 통해 외부 클래스를 호출
							//Scanner는 java.util 패키지에 포함되어있다.

public class FIFO2{				//FIFO2라는 객체를 생성

		public static void main(String[] args) { 	//접근 한정자를 public으로 설정(어디서든지 사용가능)
						//static으로 메모리를 미리 할당
						//void는 함수가 끝날 때 리턴값이 없다.
						//main은 메인 함수로 쓰여지는것
						//String[] args는 args를 문자열로 사용하겠다 라는 의미
      int arr[]={0,0,0};					//arr 이라는 배열이 가르키는 주소 메모리 값을 3으로 선언과 동시에 0,0,0으로 초기화 
      int[] r = new int[10];				//r 이라는 배열이 가르키는 주소 메모리 값을 3으로 선언과 동시에 0,0,0으로 초기화 
      System.out.print("현재 배열 상태:");	//현재 배열상태 출력문

      for(int i=0;i<3;i++){				//0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
      System.out.print(arr[i]+" "); 			//배열값 출력문
      }
      System.out.print("\n\n");			//줄바꿈

	Scanner in = new Scanner(System.in);		//객체를 생성 System.in은 키보드로 입력받기위해 사용


      for(int i=0;i<10;i++){			//0 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
         int ct=0;					//공백 검사의 횟수를 기록하기 위한 ct 변수
							//ct라는 변수가 가르키는 주소값의 메모리안에 0으로 값을 초기화
         int ct2=0;				//중복 검사의 횟수를 기록하기 위한 ct2 변수
							//ct2라는 변수가 가르키는 주소값의 메모리안에 0으로 값을 초기화
         int temp=0;				//공백 검사 시 공백 인덱스의 번호를 저장해두기 위한 temp 변수
							//temp라는 변수가 가르키는 주소값의 메모리안에 0으로 값을 초기화
	System.out.print( i + 1 +"번째 값을 입력해주세요 : " );	
	r[i] = in.nextInt();		//입력받은 정수를 변수를 a라는 주솟값이 가르키는 메모리에 저장

      System.out.println(i+1+"번째 삽입 값 : "+r[i]); 	// i+1 번째 삽입값 출력문
       for(int j=0;j<3;j++){ 			//0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
          if(arr[j]==0) { 				//arr[j]==0이라면 조건문 실행         
             temp=j;				//temp = j 대입
             break;					//값을 대입한후 for문을 바로 탈출
      	  	  }
          else {					//arr[j]가 공백이 아니라면
          ct++;					//ct값 증가
       	}   
       }
       for(int j=0;j<3;j++) {			//0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
          if(arr[j]==r[i]) {			//arr[j]값과 r[i]이 같다면
           ct2++;					//ct2 값 증가 (중복검사)
          }          
       }
       
       if(ct2==0) {				//ct2가 0이면 중복값이 없으므로
          arr[temp]=r[i];			//arr[temp]=r[i] 값 삽입
       }
       
       if((ct==3)&&(ct2==0)) {	//ct=3 검사 시 3번 증가하였으므로 arr[0], arr[1], arr[2] 모든 인덱스가 공백이 아닌 즉 포화상태, 
						//그리고 ct2=0 중복이 없다는 뜻
       arr[0]=arr[1];			//arr[]배열 값들을 앞으로 당겨줌
       arr[1]=arr[2];			//arr[1] = arr[2]
       arr[2]=r[i];				//r[i] 값을 arr[2]마지막 값에 넣어준다
       }
     
      System.out.print(i+1+"번째 삽입 후 결과 : ");		//i+1번째 삽입 후 결과 출력문
      for(int k=0;k<3;k++){						//0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
      System.out.print(arr[k]+" "); 					//arr[k]값 출력문
      }
      System.out.println();						//줄바꿈
      } 
      System.out.print("\n"+"최종 배열 상태 : ");		//최종 배열상태 출력문
      for(int j=0;j<3;j++){						//0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
         System.out.print(arr[j]+" ");				//arr[j]값 출력문
      }
   }
}

public class FIFO {				//FIFO라는 객체를 생성

		public static void main(String[] args) { 	//접근 한정자를 public으로 설정(어디서든지 사용가능)
						//static으로 메모리를 미리 할당
						//void는 함수가 끝날 때 리턴값이 없다.
						//main은 메인 함수로 쓰여지는것
						//String[] args는 args를 문자열로 사용하겠다 라는 의미
      int arr[]={0,0,0};					//arr 이라는 배열이 가르키는 주소 메모리 값을 3으로 선언과 동시에 0,0,0으로 초기화 
      int r[]={1,2,2,3,4};					//r 이라는 배열이 가르키는 주소 메모리 값을 5로 선언과 동시에 1,2,2,3,4로 초기화 
      System.out.print("현재 배열 상태:");	//현재 배열상태 출력문
      for(int i=0;i<3;i++){				//0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
      System.out.print(arr[i]+" "); 			//배열값 출력문
      }
      System.out.print("\n\n");			//줄바꿈

      for(int i=0;i<5;i++){			//0 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
         int ct=0;					//공백 검사의 횟수를 기록하기 위한 ct 변수
							//ct라는 변수가 가르키는 주소값의 메모리안에 0으로 값을 초기화
         int ct2=0;				//중복 검사의 횟수를 기록하기 위한 ct2 변수
							//ct2라는 변수가 가르키는 주소값의 메모리안에 0으로 값을 초기화
         int temp=0;				//공백 검사 시 공백 인덱스의 번호를 저장해두기 위한 temp 변수
							//temp라는 변수가 가르키는 주소값의 메모리안에 0으로 값을 초기화
      System.out.println(i+1+"번째 삽입 값 : "+r[i]); 	// i+1 번째 삽입값 출력문
       for(int j=0;j<3;j++){ 			//0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
          if(arr[j]==0) { 				//arr[j]==0이라면 조건문 실행         
             temp=j;				//temp = j 대입
             break;					//값을 대입한후 for문을 바로 탈출
      	  	  }
          else {					//arr[j]가 공백이 아니라면
          ct++;					//ct값 증가
       	}   
       }
       for(int j=0;j<3;j++) {			//0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
          if(arr[j]==r[i]) {			//arr[j]값과 r[i]이 같다면
           ct2++;					//ct2 값 증가 (중복검사)
          }          
       }
       
       if(ct2==0) {				//ct2가 0이면 중복값이 없으므로
          arr[temp]=r[i];			//arr[temp]=r[i] 값 삽입
       }
       
       if((ct==3)&&(ct2==0)) {	//ct=3 검사 시 3번 증가하였으므로 arr[0], arr[1], arr[2] 모든 인덱스가 공백이 아닌 즉 포화상태, 
						//그리고 ct2=0 중복이 없다는 뜻
       arr[0]=arr[1];			//arr[]배열 값들을 앞으로 당겨줌
       arr[1]=arr[2];			//arr[1] = arr[2]
       arr[2]=r[i];				//r[i] 값을 arr[2]마지막 값에 넣어준다
       }
     
      System.out.print(i+1+"번째 삽입 후 결과 : ");		//i+1번째 삽입 후 결과 출력문
      for(int k=0;k<3;k++){						//0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
      System.out.print(arr[k]+" "); 					//arr[k]값 출력문
      }
      System.out.println();						//줄바꿈
      } 
      System.out.print("\n"+"최종 배열 상태 : ");		//최종 배열상태 출력문
      for(int j=0;j<3;j++){						//0 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
         System.out.print(arr[j]+" ");				//arr[j]값 출력문
      }
   }
}

import java.util.Scanner; //Scanner를 사용하기위해 import를 통해 외부 클래스를 호출
//Scanner는 java.util 패키지에 포함되어있다.

public class Mum_Sort{ // Bubble_Sort라는 클래스 객체를 생성
	public static void main(String[] args) {// 접근 한정자를 public으로 설정(어디서든지 사용가능)
		// static으로 메모리를 미리 할당
		// void는 함수가 끝날 때 리턴값이 없다.
		// main은 메인 함수로 쓰여지는것
		// String[] args는 args를 문자열로 사용하겠다 라는 의미

			int[] arr = new int[5];				//arr[] 이라는 배열이 가르키는 주소 메모리 값을 5로 설정 
			int temp =0;					// temp라는 변수가 가르키는 주소 값에 메모리안에 0을 선언 0으로 초기화

		Scanner in = new Scanner(System.in);		//객체를 생성 System.in은 키보드로 입력받기위해 사용
		for (int i = 0; i < 5; i++) { 							// 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식 0~4까지 1++
			System.out.print(i+1 + "번째 값을 입력해주세요 : "); 	//입력받을 값의 출력문
			arr[i] = in.nextInt(); 							//입력받은 정수형 변수를 arr[]이라는 주솟값이 가르키는 메모리에 저장
		}
		for (int j = 0; j < 2; j++) { 					// 0~1까지 1씩 증가//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
			for (int i = j; i < 4-j; i++) { 				// j~4-j까지 1씩 증가 //조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
				if (arr[i] > arr[i + 1]) { 			// arr[i]가 a[i+1]보다 클때 실행
					temp = arr[i]; 				// temp, arr[i] 을 템프로 교환
					arr[i] = arr[i + 1]; 			// arr[i] 와 arr[i+1]를 교환
					arr[i + 1] = temp; 			// arr[i+1]을 temp와 교환
				}
				System.out.print("정렬 ---> :  ");		//정렬 확인 출력문
				for (int c = 0; c < 5; c++) {			//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식 0~4까지 1++
					System.out.print(arr[c] + " ");	//배열 확인 출력문
				}
				System.out.println(" ");			//줄 띄우기
			}
			System.out.println(" ");				//줄 띄우기
			for (int d = 3; d >= j+1; d--) { 			// 3부터 j+1까지 1씩 감소 //조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
				if (arr[d] < arr[d - 1]) { 			// arr[d]가 a[d-1]보다 클때 실행
					temp = arr[d]; 				// temp, arr[d] 을 템프로 교환
					arr[d] = arr[d - 1]; 			// arr[d] 와 arr[d-1]를 교환
					arr[d - 1] = temp; 			// arr[d-1]을 temp와 교환
				}
				System.out.print("정렬 ---> :  ");		//정렬 확인 출력문	
				for (int c = 0; c < 5; c++) {			//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식 0~4까지 1++
					System.out.print(arr[c] + " ");	//배열 확인 출력문
				}
				System.out.println(" ");			//줄 띄우기
			}
			System.out.println(" ");				//줄 띄우기
		}
		System.out.println("=====data====="); 				// 출력문
		for (int i = 0; i < 5; i++) { 							// 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식으로 0~4까지 1++
			System.out.println(i + 1 + "번째 숫자 - " + arr[i]); 	// 마지막 정렬된 코드 확인
		}
	}
}

import java.util.Scanner; //Scanner를 사용하기위해 import를 통해 외부 클래스를 호출
//Scanner는 java.util 패키지에 포함되어있다.

public class Both_Sort{ // Bubble_Sort라는 클래스 객체를 생성
	public static void main(String[] args) {// 접근 한정자를 public으로 설정(어디서든지 사용가능)
		// static으로 메모리를 미리 할당
		// void는 함수가 끝날 때 리턴값이 없다.
		// main은 메인 함수로 쓰여지는것
		// String[] args는 args를 문자열로 사용하겠다 라는 의미

			int[] arr = new int[5];				//arr[] 이라는 배열이 가르키는 주소 메모리 값을 5로 설정 
			int temp =0;					// temp라는 변수가 가르키는 주소 값에 메모리안에 0을 선언 0으로 초기화

		Scanner in = new Scanner(System.in);			//객체를 생성 System.in은 키보드로 입력받기위해 사용

		for (int i = 0; i < 5; i++) { 		// 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식 0~4까지 1++
			System.out.print(i+1 + "번째 값을 입력해주세요 : "); 		//입력받을 값의 출력문
			arr[i] = in.nextInt();								//입력받은 정수형 변수를 arr[]이라는 주솟값이 가르키는 메모리에 저장
		}

		for (int j = 0; j < 2; j++) {				// 0~1까지 1씩 증가//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
			for (int i = 0; i < 4; i++) { 			// 0~3까지 1씩 증가 //조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
				if (arr[i] > arr[i + 1]) { 		// arr[i]가 a[i+1]보다 클때 실행
					temp = arr[i]; 			// temp, arr[i] 을 템프와 교환
					arr[i] = arr[i + 1]; 		// arr[i] 와 arr[i+1]를 교환
					arr[i + 1] = temp; 		// arr[i+1]을 temp와 교환
				}
				System.out.print("정렬 ---> :  ");			//정렬 확인 출력문
				for (int c = 0; c < 5; c++) {				//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식 0~4까지 1++
					System.out.print(arr[c] + " ");		//배열 확인 출력문
				}
				System.out.println(" ");				//줄 띄우기
			}
			for (int d = 4; d > 0; d--) { 				// 0~3까지 1씩 증가 //조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
				if (arr[d] < arr[d - 1]) {			// arr[d]가 a[d-1]보다 클때 실행
					temp = arr[d]; 				// temp, arr[d] 을 템프로 교환
					arr[d] = arr[d - 1]; 			// arr[d] 와 arr[d-1]를 교환
					arr[d - 1] = temp; 			// arr[d-1]을 temp와 교환
				}
				System.out.print("정렬 ---> :  ");		//정렬 확인 출력문
				for (int c = 0; c < 5; c++) {			//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식 0~4까지 1++
					System.out.print(arr[c] + " ");	//배열 확인 출력문
				}
				System.out.println(" ");			//줄 띄우기
			}
		}
		System.out.println("=====data====="); 		// 출력문
		for (int i = 0; i < 5; i++) { 					// 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식으로 0~4까지 1++
			System.out.println(i + 1 + "번째 숫자 - " + arr[i]); 	// 마지막 정렬된 코드 확인
		}
	}
}

import java.util.Scanner;	//Scanner를 사용하기위해 import를 통해 외부 클래스를 호출
							//Scanner는 java.util 패키지에 포함되어있다.

public class Bubble_Sort {		//Bubble_Sort라는 클래스 객체를 생성
		public static void main(String[] args) {//접근 한정자를 public으로 설정(어디서든지 사용가능)
						//static으로 메모리를 미리 할당
						//void는 함수가 끝날 때 리턴값이 없다.
						//main은 메인 함수로 쓰여지는것
						//String[] args는 args를 문자열로 사용하겠다 라는 의미
int[] arr = new int[5];
int temp =0;
						//값 초기화
Scanner in = new Scanner(System.in);

for(int i=0; i<5; i++){				//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
System.out.print( i+1 + "번째 값을 입력해주세요 : " );			//0~4까지 1씩 증가 출력문
	 arr[i] = in.nextInt();						//Scanner 입력
}
		for(int j=0; j<4; j++){		//0~4까지 1씩 증가//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
			for(int i=0; i<4; i++){		//0~3까지 1씩 증가 //조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
				if(arr[i] > arr[i+1]){		//arr[i]가 a[i+1]보다 클때 실행
				temp = arr[i];		//temp, arr[i] 을 템프로 교환 
				arr[i] = arr[i+1];		//arr[i] 와 arr[i+1]를 교환 
				arr[i+1] = temp;			//arr[i+1]을 temp와 교환 
					}
					System.out.print(j+1 + " - " + i+1+ "번째 정렬 : " );		
						for(int c=0; c<5; c++){		
						System.out.print(arr[c]+ " "); 		
				}
				System.out.println("");			
			}
		}
	System.out.println("=====data=====");				//출력문 
	for(int i=0; i<5; i++){							//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식으로 0~4까지 1++ 
		System.out.println(i+1 + "번째 숫자 - " + arr[i]);			//마지막 정렬된 코드 확인 
		}
	}
}

import java.util.Scanner;	//Scanner를 사용하기위해 import를 통해 외부 클래스를 호출
					//Scanner는 java.util 패키지에 포함되어있다.

public class Sort{					//Sort 이라는 객체를 생성
		public static void main(String[] args) { //접근 한정자를 public으로 설정(어디서든지 사용가능)
						//static으로 메모리를 미리 할당
						//void는 함수가 끝날 때 리턴값이 없다.
						//main은 메인 함수로 쓰여지는것
						//String[] args는 args를 문자열로 사용하겠다 라는 의미

int[] arr = new int[4];				//배열 선언
int temp = 0;
Scanner in = new Scanner(System.in);		//객체를 생성 System.in은 키보드로 입력받기위해 사용


for(int i=0; i<4; i++){				//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
System.out.print( i+1 + "번째 값을 입력해주세요 : " );			//0~4까지 1씩 증가 출력문
	 arr[i] = in.nextInt();						//Scanner 입력
}

for(int j=0; j<5; j++){		//0~4까지 1씩 증가//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
for(int i=0; i<3; i++){		//0~2까지 1씩 증가 //조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
	if(arr[i] > arr[i+1]){		//arr[i]가 a[i+1]보다 클때 실행
	temp = arr[i];		//temp, arr[i], arr[i+1] 을 템프로 솔트해준다
	arr[i] = arr[i+1];
	arr[i+1] = temp;
		}
	}
}

for(int i=0; i<=4; i++){		//0~4까지 1씩 증가//조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
	System.out.println(i+1 + "번째 값 : " +arr[i]);		//출력문
		}
	}
}