개발 다이어리

코드

class Main {
	public void DFS(int n){
		if(n==0) {
			System.out.println();
			return;
		}
		else{
			DFS(n/2);
			System.out.print(n%2);
		}
	}
	public void solution(int n){
		DFS(n);
	}
	public static void main(String[] args){
		Main T = new Main();
		T.solution(8389017);
		T.solution(16678809);
		T.solution(16359297);
		T.solution(15198105);
		T.solution(10484121);
		T.solution(16777215);
		T.solution(12583161);
		System.out.println();
		System.out.println(Integer.toBinaryString(16776441));
		System.out.println(Integer.toBinaryString(16776441));
		System.out.println(Integer.toBinaryString(8388633));
		System.out.println(Integer.toBinaryString(16728057));
		System.out.println(Integer.toBinaryString(16728057));
		System.out.println(Integer.toBinaryString(16728057));
	}	
}

결과

100000000000000110011001
111111100111111110011001
111110011001111110000001
111001111110011110011001
100111111111100110011001
111111111111111111111111
110000000000000011111001
111111111111110011111001
111111111111110011111001
100000000000000000011001
111111110011111111111001
111111110011111111111001
111111110011111111111001

코드

package algorithm07;

public class Main {
	//자기 자신을 끊임 없이 호출
	static void recursive(int n) {
		if (n == 0) //재귀함수는 종료 조건이 가장 중요하다.
			return;
		else {
			System.out.println(n);
			recursive(n - 1); //재귀 기준점
			System.out.println(n);
		}
	}

	public static void main(String[] args) {
		Main.recursive(5);
	}
}

결과ㅈ

5
4
3
2
1
1
2
3
4
5

가장 위부터 n은 0 , 1,  2,  3,  4,  5

여기서 0은 탈출조건이다.

재귀함수는 자기자신을 끊임없이 호출하는 함수이다. 

그렇기에 끊임없이 호출하는 구조를 빠져나오는 조건이 가장 중요하다.

재귀함수를 실제 사용한다면, 중요한 것은 재귀함수를 호출하기 전/후 작업이다.

위 결과에서 54321 는 재귀를 호출해 나아가며 실행됐다.

반대로 12345는 재귀 끝에 도달하고,(엄밀히 말하면 n==0) 되돌아오면서 실행됐다.

재귀함수는 반복문 보다 성능이 않좋다. 

이유는 함수(메서드)이기 때문이다.  메서드는 하나하나가 스택 프레임이 생긴다. 

프레임 생성에 따른 비용소모가 발생한다. 또한 메서드이기에 복귀주소, this 생성 등 부차적인 절차가 생긴다. 

이런 이유에도 재귀함수를 쓰는 이유는 재귀함수가 주는 코드의 간결함, 가독성 때문이다.

재귀함수의 사용 시 주의할 점은 정도가 심하다면 스택오버플로우가 발생할 수 있다는 점이 있겠다.

대부분 재귀함수는 반복문으로 변경할 수 있으므로, 그럴 땐 반복문을 사용해야 한다.

재귀함수 관련 포스팅

코드

import java.util.*;
//뮤직비디오(결정알고리즘)

class 뮤직비디오_ {
    private static int count(int[] arr, int mid) {
        int sum = 0, count =1; // 기본 배치를 한 개 하고 시작
        System.out.println("======="+mid+"=======");
        for(int num : arr) {
            sum+=num;
            if(mid<sum) {
                sum = num;
                count++;
            }
        }
        System.out.println("앨범 수 "+count);
        return count;
    }
    
    public static void main(String[] args){
        int answer=0;
        int[] arr = new Random().ints(10, 1,10)
                                .sorted()
                                .toArray();
        System.out.println(Arrays.toString(arr));
        int lt = arr[arr.length-1]; //가장 큰 노래 길이가 최소 한 1곡은 다 들어감
        int rt = Arrays.stream(arr).sum();//모든 노래 길이 합이 가장 큰 경우의 수
        int size = 5; // 앨범 개수
        
        
        while(lt<=rt) {
            int mid = (lt+rt)/2;
            if(count(arr, mid) <= size) {
                answer = mid;
                rt = mid-1;
            }else {
                lt = mid+1;
            }
        }
        System.out.println("앨범 당 합 곡길이 :"+answer);
        
    }
}

결과

[3, 6, 6, 6, 6, 7, 7, 8, 9, 9]
=======38=======
앨범 수 2
=======23=======
앨범 수 4
=======15=======
앨범 수 6
=======19=======
앨범 수 4
=======17=======
앨범 수 5
=======16=======
앨범 수 6
앨범 당 합 곡길이 :17

반드시 이분 검색을 이용한 알고리즘은 정렬이 필수 

코드

import java.util.*;
//마구간 정하기(결정알고리즘)
/*
5 3
1 2 8 4 9
*/
class 마구간정하기_ {

	private int count(int[] arr, int mid) {
		System.out.println("======"+mid+"======");
		int cnt = 1; // 맨 처음을 당연히 배치하니 1을 둔다.
		int position = arr[0];
		
		System.out.print(position+",");
		for(int i = 1 ; i < arr.length ; i++){
			if(arr[i]-position >= mid ) {
				System.out.print(arr[i]+",");
				cnt++;
				position = arr[i];
			}
		}
		System.out.println();
		
		return cnt;
	}

	public static void main(String[] args){
		
		마구간정하기_ T = new 마구간정하기_();
		int[] arr = new Random().ints(1, 30)
				                .distinct()
				                .limit(10)
				                .sorted()
				                .toArray();
		int c = 5;
		
		System.out.println(Arrays.toString(arr));
		int answer = 0;
		int lt = 1; // 주의할 것 arr[0]로 하면 답이 안 나올 수 있음
		int rt = arr[arr.length-1];
		
		while(lt<=rt) {
			int mid = (lt+rt)/2;
			if(T.count(arr, mid) >= c ) {
				//가능하니 거리를 넓여본다.
				answer = mid;
				lt = mid+1;
			}else {
				//불가능하니 거리를 좁혀본다.
				rt = mid-1;
			}
			
			
		}
		System.out.println(c+" 배치 가능한 적절한 거리 = "+answer);
		
	}
}

결과

[1, 5, 7, 11, 15, 18, 19, 23, 28, 29]
======15======
1,18,
======7======
1,11,18,28,
======3======
1,5,11,15,18,23,28,
======5======
1,7,15,23,28,
======6======
1,7,15,23,29,
5 배치 가능한 적절한 거리 = 6

결정알고리즘은 기본이 이진 검색이다. 따라서 정렬이 필수

코드

import java.util.*;
//원래 키순으로 정렬된 배열에서 한 친구가 자리를 바궜다.
//그래서 배열이 뒤틀어져 있다. 
// 이 상황에서 자리를 바꾼 친구 두 친구 번호를 찾기
class 장난꾸러기_ {	
	public static void main(String[] args){
		int[] arr=new int[] {120 ,125, 152, 130, 135, 135, 143, 127, 160};
		ArrayList<Integer> answer=new ArrayList<>();
		int[] arr2 = new int[arr.length];
		
		for(int i=0;i<arr.length;i++) {
			arr2[i] = arr[i];
		}
		for(int i=0;i<arr.length;i++) {
			for(int j=i+1;j<arr.length;j++) {
				if(arr[i]>arr[j]) {
					int tmp = arr[i];
					arr[i] = arr[j];
					arr[j] = tmp;
				}
			}
		}
		for(int i=0;i<arr.length;i++) {
			if(arr[i]!=arr2[i]) answer.add(i+1);
		}
		
		System.out.println(answer);
	}
}

결과

[3, 8]

코드

import java.util.*;
//Least Recently Used
class LRU {	
	public static void main(String[] args){
		int[] arr = new Random().ints(20, 1, 11)
		            .toArray();
		int size = 5; //캐시 사이즈
		int[] cache = new int[size];
		
		System.out.println(Arrays.toString(arr));
		//전체 작업을 순회
		for(int i=0;i< arr.length;i++) {
			int tmpIndex = -1;
			int value = arr[i];
			//캐시에 이미 존재하는지
			for(int j=0;j<cache.length;j++) {
				if(cache[j] == value) {
					tmpIndex=j;
					break;
				}
			}
			//캐시에 존재할 경우 그 자리를 제외하고 뒤로 밀기
			int j = tmpIndex != -1 ? tmpIndex : cache.length-1;
			for(; 0<j;j--) {
				cache[j] = cache[j-1];
			}
			cache[0] = arr[i];
			System.out.println(Arrays.toString(cache)+"입력값 =" + arr[i]);
		}
	}
}

결과

[4, 2, 3, 8, 4, 9, 8, 5, 8, 10, 3, 10, 9, 7, 6, 5, 9, 3, 10, 8]
[4, 0, 0, 0, 0]입력값 =4
[2, 4, 0, 0, 0]입력값 =2
[3, 2, 4, 0, 0]입력값 =3
[8, 3, 2, 4, 0]입력값 =8
[4, 8, 3, 2, 0]입력값 =4
[9, 4, 8, 3, 2]입력값 =9
[8, 9, 4, 3, 2]입력값 =8
[5, 8, 9, 4, 3]입력값 =5
[8, 5, 9, 4, 3]입력값 =8
[10, 8, 5, 9, 4]입력값 =10
[3, 10, 8, 5, 9]입력값 =3
[10, 3, 8, 5, 9]입력값 =10
[9, 10, 3, 8, 5]입력값 =9
[7, 9, 10, 3, 8]입력값 =7
[6, 7, 9, 10, 3]입력값 =6
[5, 6, 7, 9, 10]입력값 =5
[9, 5, 6, 7, 10]입력값 =9
[3, 9, 5, 6, 7]입력값 =3
[10, 3, 9, 5, 6]입력값 =10
[8, 10, 3, 9, 5]입력값 =8

최근 사용한 데이터를 캐시에 저장하는 등의 수정이 자주 발생한다,  배열보단 LinkedList 같은 자료구조가 좋다.

코드

import java.util.*;
class 버블정렬 {	
//뒷자리를 제일 큰 수로 채우면서 줄여간다. 
//따라서 매 순회마다 뒷자리가 차곡차곡 큰 수로 채워진다.
	public static void main(String[] args){
		int[] arr = new Random().ints(10, 50, 100).toArray();
		for(int i=0;i<arr.length-1;i++) {
			System.out.println("i 순회 중 = "+ i);
			for(int j=0;j<arr.length-1-i;j++) {
				if(arr[j]>arr[j+1]) {
					System.out.println("arr["+j+"]="+arr[j]+" <==> arr["+j+"+1]="+arr[j+1]);
					for(int z=0;z<j-1;z++) System.out.print("    ");
					System.out.println("  *");
					System.out.println(Arrays.toString(arr));
					int tmp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = tmp;
					System.out.println(Arrays.toString(arr));
					System.out.println("========================================");
				}
			}
		}
		
	}
}

결과

i 순회 중 = 0
arr[0]=69 <==> arr[0+1]=58
  *
[69, 58, 65, 96, 91, 95, 82, 72, 96, 85]
[58, 69, 65, 96, 91, 95, 82, 72, 96, 85]
========================================
arr[1]=69 <==> arr[1+1]=65
  *
[58, 69, 65, 96, 91, 95, 82, 72, 96, 85]
[58, 65, 69, 96, 91, 95, 82, 72, 96, 85]
========================================
arr[3]=96 <==> arr[3+1]=91
          *
[58, 65, 69, 96, 91, 95, 82, 72, 96, 85]
[58, 65, 69, 91, 96, 95, 82, 72, 96, 85]
========================================
arr[4]=96 <==> arr[4+1]=95
              *
[58, 65, 69, 91, 96, 95, 82, 72, 96, 85]
[58, 65, 69, 91, 95, 96, 82, 72, 96, 85]
========================================
arr[5]=96 <==> arr[5+1]=82
                  *
[58, 65, 69, 91, 95, 96, 82, 72, 96, 85]
[58, 65, 69, 91, 95, 82, 96, 72, 96, 85]
========================================
arr[6]=96 <==> arr[6+1]=72
                      *
[58, 65, 69, 91, 95, 82, 96, 72, 96, 85]
[58, 65, 69, 91, 95, 82, 72, 96, 96, 85]
========================================
arr[8]=96 <==> arr[8+1]=85
                              *
[58, 65, 69, 91, 95, 82, 72, 96, 96, 85]
[58, 65, 69, 91, 95, 82, 72, 96, 85, 96]
========================================
i 순회 중 = 1
arr[4]=95 <==> arr[4+1]=82
              *
[58, 65, 69, 91, 95, 82, 72, 96, 85, 96]
[58, 65, 69, 91, 82, 95, 72, 96, 85, 96]
========================================
arr[5]=95 <==> arr[5+1]=72
                  *
[58, 65, 69, 91, 82, 95, 72, 96, 85, 96]
[58, 65, 69, 91, 82, 72, 95, 96, 85, 96]
========================================
arr[7]=96 <==> arr[7+1]=85
                          *
[58, 65, 69, 91, 82, 72, 95, 96, 85, 96]
[58, 65, 69, 91, 82, 72, 95, 85, 96, 96]
========================================
i 순회 중 = 2
arr[3]=91 <==> arr[3+1]=82
          *
[58, 65, 69, 91, 82, 72, 95, 85, 96, 96]
[58, 65, 69, 82, 91, 72, 95, 85, 96, 96]
========================================
arr[4]=91 <==> arr[4+1]=72
              *
[58, 65, 69, 82, 91, 72, 95, 85, 96, 96]
[58, 65, 69, 82, 72, 91, 95, 85, 96, 96]
========================================
arr[6]=95 <==> arr[6+1]=85
                      *
[58, 65, 69, 82, 72, 91, 95, 85, 96, 96]
[58, 65, 69, 82, 72, 91, 85, 95, 96, 96]
========================================
i 순회 중 = 3
arr[3]=82 <==> arr[3+1]=72
          *
[58, 65, 69, 82, 72, 91, 85, 95, 96, 96]
[58, 65, 69, 72, 82, 91, 85, 95, 96, 96]
========================================
arr[5]=91 <==> arr[5+1]=85
                  *
[58, 65, 69, 72, 82, 91, 85, 95, 96, 96]
[58, 65, 69, 72, 82, 85, 91, 95, 96, 96]
========================================
i 순회 중 = 4
i 순회 중 = 5
i 순회 중 = 6
i 순회 중 = 7
i 순회 중 = 8

코드

import java.util.*;
//오름차순 기준
//삽입정렬은 i 크기만큼 배열만 정렬하고 i를 점점 증가시킨다.
//그래서 맨 처음은 인위적으로 0인덱스 자리를 비운다. i=1 
//1번 째 순회는 길이가 2인 배열 일부를 비교,
//n번 째 순회는 길이가 n+1인 배열 일부를 비교,
//최종으로는 입력받은 배열 전체를 비교하게 된다.
//핵심은 배열의 크기가 점점 커지면서 최종적으로 입력받은 배열 크기를 비교하게 되는데
//이때 이미 내 앞의 요소는 정렬이 되어있음을 보장한다.
//이 구조는 마치 정렬된 배열에 요소를 추가하는 것과 같다.
//이미 정렬이 되어 있는 배열에 새로운 요소를 추가하는데, 순서를 지키고 싶다고 생각해보자
//뒤에서 부터 비교하면서, 나보다 작은 수가 안나올 때까지 비교할 것이다.
//만약 나보다 작은 수가 나온다면, 비교를 멈추고 그 자리에 나를 넣을 것이다.
//따라서 새로운 요소가 가장 작은 수가 아니라면, 전체를 다 순회하지 않는다. 
class 삽입정렬 {
	public static void main(String[] args) {
		// 최대치를 높여가며 뒤부터 앞으로 정렬을 반복
		int[] arr = new Random().ints(10, 50, 100).toArray();
		for(int i = 1;i<arr.length;i++) {
			for(int j = i;j>0;j--) {
				//arr[j]가 기존 배열에 새로 추가할 요소라고 생각해보자.
				System.out.println("i 순회 중 = "+ i);
				if(arr[j]<arr[j-1] ) {
					System.out.println("arr["+j+"-1]="+arr[j-1]+" <==> arr["+j+"]="+arr[j]);
					for(int z=0;z<j-1;z++) System.out.print("    ");
					System.out.println("  *");
					System.out.println(Arrays.toString(arr));
					int tmp= arr[j];
					arr[j] = arr[j-1];
					arr[j-1] = tmp;
					System.out.println(Arrays.toString(arr));
					System.out.println("========================================");
				}else {
					//기존 배열은 정렬을 유지하고 있는 상태이다.
					//따라서, false가 나오면 그만 순회해도 되는 것이다.
					break;
				}
			}
		}
	}
}

결과

i 순회 중 = 1
arr[1-1]=65 <==> arr[1]=54
  *
[65, 54, 50, 81, 51, 65, 90, 61, 86, 62]
[54, 65, 50, 81, 51, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 2
arr[2-1]=65 <==> arr[2]=50
      *
[54, 65, 50, 81, 51, 65, 90, 61, 86, 62]
[54, 50, 65, 81, 51, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 2
arr[1-1]=54 <==> arr[1]=50
  *
[54, 50, 65, 81, 51, 65, 90, 61, 86, 62]
[50, 54, 65, 81, 51, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 3
i 순회 중 = 4
arr[4-1]=81 <==> arr[4]=51
              *
[50, 54, 65, 81, 51, 65, 90, 61, 86, 62]
[50, 54, 65, 51, 81, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 4
arr[3-1]=65 <==> arr[3]=51
          *
[50, 54, 65, 51, 81, 65, 90, 61, 86, 62]
[50, 54, 51, 65, 81, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 4
arr[2-1]=54 <==> arr[2]=51
      *
[50, 54, 51, 65, 81, 65, 90, 61, 86, 62]
[50, 51, 54, 65, 81, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 4
i 순회 중 = 5
arr[5-1]=81 <==> arr[5]=65
                  *
[50, 51, 54, 65, 81, 65, 90, 61, 86, 62]
[50, 51, 54, 65, 65, 81, 90, 61, 86, 62]
========================================
i 순회 중 = 5
i 순회 중 = 6
i 순회 중 = 7
arr[7-1]=90 <==> arr[7]=61
                          *
[50, 51, 54, 65, 65, 81, 90, 61, 86, 62]
[50, 51, 54, 65, 65, 81, 61, 90, 86, 62]
========================================
i 순회 중 = 7
arr[6-1]=81 <==> arr[6]=61
                      *
[50, 51, 54, 65, 65, 81, 61, 90, 86, 62]
[50, 51, 54, 65, 65, 61, 81, 90, 86, 62]
========================================
i 순회 중 = 7
arr[5-1]=65 <==> arr[5]=61
                  *
[50, 51, 54, 65, 65, 61, 81, 90, 86, 62]
[50, 51, 54, 65, 61, 65, 81, 90, 86, 62]
========================================
i 순회 중 = 7
arr[4-1]=65 <==> arr[4]=61
              *
[50, 51, 54, 65, 61, 65, 81, 90, 86, 62]
[50, 51, 54, 61, 65, 65, 81, 90, 86, 62]
========================================
i 순회 중 = 7
i 순회 중 = 8
arr[8-1]=90 <==> arr[8]=86
                              *
[50, 51, 54, 61, 65, 65, 81, 90, 86, 62]
[50, 51, 54, 61, 65, 65, 81, 86, 90, 62]
========================================
i 순회 중 = 8
i 순회 중 = 9
arr[9-1]=90 <==> arr[9]=62
                                  *
[50, 51, 54, 61, 65, 65, 81, 86, 90, 62]
[50, 51, 54, 61, 65, 65, 81, 86, 62, 90]
========================================
i 순회 중 = 9
arr[8-1]=86 <==> arr[8]=62
                              *
[50, 51, 54, 61, 65, 65, 81, 86, 62, 90]
[50, 51, 54, 61, 65, 65, 81, 62, 86, 90]
========================================
i 순회 중 = 9
arr[7-1]=81 <==> arr[7]=62
                          *
[50, 51, 54, 61, 65, 65, 81, 62, 86, 90]
[50, 51, 54, 61, 65, 65, 62, 81, 86, 90]
========================================
i 순회 중 = 9
arr[6-1]=65 <==> arr[6]=62
                      *
[50, 51, 54, 61, 65, 65, 62, 81, 86, 90]
[50, 51, 54, 61, 65, 62, 65, 81, 86, 90]
========================================
i 순회 중 = 9
arr[5-1]=65 <==> arr[5]=62
                  *
[50, 51, 54, 61, 65, 62, 65, 81, 86, 90]
[50, 51, 54, 61, 62, 65, 65, 81, 86, 90]
========================================
i 순회 중 = 9

코드

import java.util.*;
//오름차순 기준
//선택정렬은 앞자리부터 작은 수를 채워간다.
//즉, 1번째 순회 시 맨 앞자리에 가장 작은 수가 오고
//그 다음은 2 번째 순회 시 그 다음 자리에 그 다음으로 작은 수가 온다.
class 선택정렬 {	
	public static void main(String[] args){
		int[] arr = new Random().ints(10, 50, 101)
		            .toArray();
		// i의 역할은 인덱스로 순회하면서 가장 작은 수를 채운다.
		for(int i=0;i<arr.length-1;i++) {
			//j 역할은 i 마다 반복하면서 arr[i]보다 작은 수를 검사해 자리를 바꿔치기한다.
			System.out.println("i 순회 중 = "+ i);
			for(int j=i+1;j<arr.length;j++) {
				if(arr[i]>arr[j]) {
					System.out.println("arr["+i+"]"+arr[i]+" <==> arr["+j+"]="+arr[j]);
					for(int z=0;z<j;z++)System.out.print("    ");
					System.out.println("  *");
					System.out.println(Arrays.toString(arr));
					
					int tmp = arr[i];
					arr[i] = arr[j];
					arr[j] = tmp;
					
					System.out.println(Arrays.toString(arr));
					System.out.println("========================================");
				}
			}
		}
		System.out.println("\n"+Arrays.toString(arr));
	}
}

결과

i 순회 중 = 0
arr[0]83 <==> arr[1]=66
      *
[83, 66, 100, 60, 78, 90, 56, 67, 91, 76]
[66, 83, 100, 60, 78, 90, 56, 67, 91, 76]
========================================
arr[0]66 <==> arr[3]=60
              *
[66, 83, 100, 60, 78, 90, 56, 67, 91, 76]
[60, 83, 100, 66, 78, 90, 56, 67, 91, 76]
========================================
arr[0]60 <==> arr[6]=56
                          *
[60, 83, 100, 66, 78, 90, 56, 67, 91, 76]
[56, 83, 100, 66, 78, 90, 60, 67, 91, 76]
========================================
i 순회 중 = 1
arr[1]83 <==> arr[3]=66
              *
[56, 83, 100, 66, 78, 90, 60, 67, 91, 76]
[56, 66, 100, 83, 78, 90, 60, 67, 91, 76]
========================================
arr[1]66 <==> arr[6]=60
                          *
[56, 66, 100, 83, 78, 90, 60, 67, 91, 76]
[56, 60, 100, 83, 78, 90, 66, 67, 91, 76]
========================================
i 순회 중 = 2
arr[2]100 <==> arr[3]=83
              *
[56, 60, 100, 83, 78, 90, 66, 67, 91, 76]
[56, 60, 83, 100, 78, 90, 66, 67, 91, 76]
========================================
arr[2]83 <==> arr[4]=78
                  *
[56, 60, 83, 100, 78, 90, 66, 67, 91, 76]
[56, 60, 78, 100, 83, 90, 66, 67, 91, 76]
========================================
arr[2]78 <==> arr[6]=66
                          *
[56, 60, 78, 100, 83, 90, 66, 67, 91, 76]
[56, 60, 66, 100, 83, 90, 78, 67, 91, 76]
========================================
i 순회 중 = 3
arr[3]100 <==> arr[4]=83
                  *
[56, 60, 66, 100, 83, 90, 78, 67, 91, 76]
[56, 60, 66, 83, 100, 90, 78, 67, 91, 76]
========================================
arr[3]83 <==> arr[6]=78
                          *
[56, 60, 66, 83, 100, 90, 78, 67, 91, 76]
[56, 60, 66, 78, 100, 90, 83, 67, 91, 76]
========================================
arr[3]78 <==> arr[7]=67
                              *
[56, 60, 66, 78, 100, 90, 83, 67, 91, 76]
[56, 60, 66, 67, 100, 90, 83, 78, 91, 76]
========================================
i 순회 중 = 4
arr[4]100 <==> arr[5]=90
                      *
[56, 60, 66, 67, 100, 90, 83, 78, 91, 76]
[56, 60, 66, 67, 90, 100, 83, 78, 91, 76]
========================================
arr[4]90 <==> arr[6]=83
                          *
[56, 60, 66, 67, 90, 100, 83, 78, 91, 76]
[56, 60, 66, 67, 83, 100, 90, 78, 91, 76]
========================================
arr[4]83 <==> arr[7]=78
                              *
[56, 60, 66, 67, 83, 100, 90, 78, 91, 76]
[56, 60, 66, 67, 78, 100, 90, 83, 91, 76]
========================================
arr[4]78 <==> arr[9]=76
                                      *
[56, 60, 66, 67, 78, 100, 90, 83, 91, 76]
[56, 60, 66, 67, 76, 100, 90, 83, 91, 78]
========================================
i 순회 중 = 5
arr[5]100 <==> arr[6]=90
                          *
[56, 60, 66, 67, 76, 100, 90, 83, 91, 78]
[56, 60, 66, 67, 76, 90, 100, 83, 91, 78]
========================================
arr[5]90 <==> arr[7]=83
                              *
[56, 60, 66, 67, 76, 90, 100, 83, 91, 78]
[56, 60, 66, 67, 76, 83, 100, 90, 91, 78]
========================================
arr[5]83 <==> arr[9]=78
                                      *
[56, 60, 66, 67, 76, 83, 100, 90, 91, 78]
[56, 60, 66, 67, 76, 78, 100, 90, 91, 83]
========================================
i 순회 중 = 6
arr[6]100 <==> arr[7]=90
                              *
[56, 60, 66, 67, 76, 78, 100, 90, 91, 83]
[56, 60, 66, 67, 76, 78, 90, 100, 91, 83]
========================================
arr[6]90 <==> arr[9]=83
                                      *
[56, 60, 66, 67, 76, 78, 90, 100, 91, 83]
[56, 60, 66, 67, 76, 78, 83, 100, 91, 90]
========================================
i 순회 중 = 7
arr[7]100 <==> arr[8]=91
                                  *
[56, 60, 66, 67, 76, 78, 83, 100, 91, 90]
[56, 60, 66, 67, 76, 78, 83, 91, 100, 90]
========================================
arr[7]91 <==> arr[9]=90
                                      *
[56, 60, 66, 67, 76, 78, 83, 91, 100, 90]
[56, 60, 66, 67, 76, 78, 83, 90, 100, 91]
========================================
i 순회 중 = 8
arr[8]100 <==> arr[9]=91
                                      *
[56, 60, 66, 67, 76, 78, 83, 90, 100, 91]
[56, 60, 66, 67, 76, 78, 83, 90, 91, 100]
========================================

[56, 60, 66, 67, 76, 78, 83, 90, 91, 100]

코드

import java.util.*;
//후위연산
class 후위연산_ {	
	public static void main(String[] args){
		String str = "573*+5-323*++";
		int answer=0;
		Stack<Integer> stack = new Stack<Integer>();
		
		for(char cha : str.toCharArray()) {
			int lt = 0;
			int rt = 0;
			if(!Character.isDigit(cha)) {
//			if(cha =='+'||cha =='-'||cha =='/'||cha =='*') {
				rt = stack.pop();
				lt = stack.pop();
				answer = cha=='+'? Integer.sum(lt, rt) 
						:cha=='-'? Math.subtractExact(lt, rt)
						:cha=='/'? Math.floorDiv(lt, rt) 
								 : Math.multiplyExact(lt, rt);
				stack.push(answer);
			}else {
				System.out.println("char:"+cha + " char아스키:"+ Integer.valueOf(cha));
				stack.push(cha-'0');
				// char형 숫자에 '0'을 빼면 우리가 생각하는 숫자(int)가 된다.
				// -48도 가능하다.
			}
		}
		System.out.println("char: 0 char아스키:"+ Integer.valueOf('0'));
		System.out.println(answer);
	}
}

결과

char:5 char아스키:53
char:7 char아스키:55
char:3 char아스키:51
char:5 char아스키:53
char:3 char아스키:51
char:2 char아스키:50
char:3 char아스키:51
char: 0 char아스키:48
30