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

		int mem[] = { 10, 2, 1, 12, 4 }; // 정수형 mem 배열에 10, 2, 1, 12, 4 값으로 초기화 크기는 5 메모리값이다
		int selmem = 3; // 정수형 변수 selmem 값을 3으로 초기화 사용할 메모리값

		System.out.println(); // 줄 띄우기

		System.out.print("메모리 크기 : "); // 메모리크기 출력문
		for (int i = 0; i < 5; i++) { // i는 0~4까지
			System.out.print(mem[i] + "  "); // 메모리 크기
		}
		System.out.println(); // 줄 띄우기
		System.out.println("현재 넣을 값 : " + selmem); // selmem값 출력문

		for (int i = 0; i < 5; i++) { // i는 0~4까지
			if (selmem < mem[i]) { // selmem보다 mem[i]가 작다면 조건문 실행
				System.out.print("사용된 메모리 공간 : " + mem[i]); // 사용된 메모리공간 출력문
				mem[i] = mem[i] - selmem; // mem[i]에 selmem값 빼기
				System.out.println("[" + mem[i] + "]"); // 빠진 메모리값 보여주기
				break; // 값을 뻈으면 for문 탈출
			}
		}

	}
}

public class HRN {						//HRN이라는 객체를 생성
	public static void main(String[] args) {		//접근 한정자를 public으로 설정(어디서든지 사용가능)
								//static으로 메모리를 미리 할당
								//void는 함수가 끝날 때 리턴값이 없다.
								//main은 메인 함수로 쓰여지는것
								//String[] args는 args를 문자열로 사용하겠다 라는 의미
		float temp=0;				//프로세스 우선순위의 값을 정렬할 실수로 선언된 temp
		int temp2=0;				//나머지 도착시간,시작시간,종료시간,실행시간 정렬을위해 정수로 선언된 temp
		int[] end = new int[5];			//종료시간 크기5 end 배열 선언
		int[] start = new int[5];			//시작시간 크기5 start 배열 선언
		int[] wait = new int[5];			//대기시간 크기5 wait 배열 선언
		int[] arrival = {0, 1, 2, 3, 4};		//도착시간 크기5 arrival 0,1,2,3,4로 초기화한 배열 선언
		int[] run = {10, 28, 6, 4, 14};		//실행시간 크기5 run 10,28,6,4,14로 초기화한 배열 선언
		int[] process_num = {1, 2, 3, 4, 5};	//프로세스 번호 크기5 process_num 1,2,3,4,5로 초기화한 배열 선언
		float[] process = new float[5];		//프로세스 우선순위 값 크기5 인 배열 선언
		end[0] = 10; start[0] = 0;			//프로세스 1번째 종료시간과 시작시간 값 초기화
		
		for(int i=1; i<5; i++) {			//1 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
								//시간들 계산하는 for문	1번 프로세스는 고정 그래서 1부터 시작
			wait[i] = run[0] - arrival[i];		//대기시간 구하는 계산식
			process[i] = (run[i] + wait[i] + process[i-1])/run[i];		//프로세스 우선순위 값 구하는 계산식
			end[i] = end[i] + run[i];						//종료시간 계산식
		}
		for(int j=1; j<3; j++) {					//1 ~ 2까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
			for(int i=1; i<4; i++) {				//1 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식	
										//1부터 시작하는 이유는 프로세스1번은 정렬을 할 필요가 없기 때문
				if(process[i] < process[i+1]) {		//프로세스 우선순위 값이 큰 순서대로 나머지 값도 다 같이 정렬해주는 if문
					temp = process[i];			//우선순위값인 process 정렬
					process[i] = process[i+1];
					process[i+1] = temp;
					temp2 = process_num[i];		//프로세스번호 변수인 process_num 값 정렬
					process_num[i] = process_num[i+1];
					process_num[i+1] = temp2;
					temp2 = end[i];			//종료시간 변수인 end 값 정렬
					end[i] = end[i+1];
					end[i+1] = temp2;
					temp2 = arrival[i];			//도착시간 변수인 arrival 값 정렬
					arrival[i] = arrival[i+1];
					arrival[i+1] = temp2;
					temp2 = run[i];			//실행시간 변수인 run 값 정렬
					run[i] = run[i+1];
					run[i+1] = temp2;
				}
			}
		}
		for(int i=1; i<5; i++) {			//1 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
								//프로세스1번 말고 나머지 종료시간, 시작시간 구하는 for문
			end[i] = end[i] + end[i-1];	//종료시간값 구하는 계산식
			start[i] = end[i-1]+1;		//시작시간값 구하는 계산식
		}
		System.out.print("프로세스번호  도착시간	 시작시간	 종료시간	 실행시간");	//프로세스번호, 도착시간, 시작시간, 종료시간, 실행시간 출력문
		System.out.println();										//줄바꿈
		for(int i=0; i<5; i++) {					//0 ~ 4까지 1++ 조건식이 트루일때만 실행 그리고 문장을 갔다가 증감식을가고 다시 조건식
			System.out.println("  p" + process_num[i] +"	  	"+ arrival[i]+" 	  "+start[i]+" 		  "+end[i]+" 		  "+run[i]);	
		}								//프로세스번호, 도착시간, 시작시간, 종료시간, 실행시간 배열값 출력문
	}
}

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]); 	// 마지막 정렬된 코드 확인
		}
	}
}