package com.self;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class BufferedReaderTest {

        public static void main(String[] args) throws NumberFormatException, IOException {
                
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                                          //BufferedReader 한줄씩 입력 받음
                StringTokenizer st =null; //값을 한글자씩 분리시키기 위해 사용한다
                
                //String s = br.readLine();
                int n = Integer.parseInt(br.readLine()); //입력 받는 동시에 int 형으로 변화
                
                int[] arrays = new int[n+1];
                st=new StringTokenizer(br.readLine()); //한글자씩 분리해서 저장
                
                
                 for (int i = 1; i <= n; i++) {
         arrays[i] = Integer.parseInt(st.nextToken());
         }
                
                for (int i = 1; i < arrays.length; i++) {
                        System.out.print(arrays[i]+" ");
                }
        }

}


StringTokenizer

보통
1 2 3 4 5 6 7 8 9

이런식으로 값이 들어오기 때문에  StringTokenizer 으로 한글자씩 분리해서 배열에 넣고 사용한다


저작자표시

'알고리즘' 카테고리의 다른 글

Queue -java  (0) 2019.01.23
후위 표현식 계산하기  (0) 2019.01.22
후위 표현식 만들기 (stack) - java  (0) 2019.01.22

#Queue

큐의 선입선출 구조
스택과 마찬가지로 삽입과 삭제의 위치가 제한적인 자료구조
-큐의 뒤에서는 삽입만 하고, 큐의 앞에서는 삭제만 이루어지는 구조
삽입 : enQueue
삭제 : deQueue

front = rear 상태가 같으면 공백
둘다 -1 이면 처음 구조
front = 가장 첫번째 데이터의 한칸전
rear = 마지막 데이터의 위치


기본 개념과 구조는 이렇게 있다.




public class Queue {
        
        public static int Queue[] = new int[10];
        public static int front = -1;
        public static int rear = -1;
        
        public static void main(String[] args) {
                
                enQueue(1);
                enQueue(2);
                enQueue(3);
                enQueue(4);
                enQueue(5);
                enQueue(6);
                
                System.out.println(deQueue());
                System.out.println(deQueue());
                System.out.println(deQueue());
                
        }
        
        public static boolean isEmpty() {
                return front == rear; //rear와 front 가 같으면 비어있는 상태이다
        }
        
        public static boolean isFull() {
                return rear == Queue.length-1; // Queue 전체 크기보다 -1 작으면 가득찬 상태이다
        }
        
        public static void enQueue(int i) {
                if(isFull()) { //가득 찼는지 우선 확인해야하고
                        System.out.println("에러");
                }else {
                        Queue[++rear] = i; //안찼으면 enqueue 할 수 있다.
                }
        }
        
        public static int Qpeek() {
                return Queue[front+1]; //삭제 하는건 아니고 그냥 값만 가지고 오는 경우
                
        }

        public static int deQueue() {
                if(isEmpty()) {
                        System.out.println("에러");
                }
                return Queue[++front]; //가지고 오고 front를 늘려서 삭제 하는 경우
        }
        
}


저작자표시

'알고리즘' 카테고리의 다른 글

BufferedReader 로 입출력 속도 단축하기  (0) 2019.01.23
후위 표현식 계산하기  (0) 2019.01.22
후위 표현식 만들기 (stack) - java  (0) 2019.01.22

후위 표현식 계산하기 

후위 표현식으로 만들고, 그 후위 표현식을 계산할려면 


기본 개념은 이렇다.

stack 구조를 하나 만들고 

후위 표현식으로 바꾼 문자열을 순서대로 읽었을때 들어가는 글자 하나 하나가 만약 숫자면 스택에 두고 연산자 이면 스택에 쌓은 숫자를 2개 꺼내서 계산하고 다시 스택에 저장하는 방식으로 계산한다.


이때 중요한점은 먼저 꺼내는 값이 num2 즉 저기 연산에서 2-8// 8에 들어 가야한다 그리고 다음에 꺼내는 값이  num1에 들어가고 계산해서 다시 스택에 쌓아주면 된다.


package com.ssafy.algo5;
/**
* 후위 표기식을 계산해서 출력하기
*
* input:
* 6 5 2 8 - * 2 / +
*
* output:
* -9
*
*/
import java.util.Scanner;

public class Z18_Cal3 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] str = sc.nextLine().split(" ");
        int[] stack = new int[str.length];
        int top =-1;
        
        for(int i = 0; i<str.length; i++) {
            char c = str[i].charAt(0);
            int num1, num2;
            
            switch (c) {
            case '+':
                num2 = stack[top--];
                num1 = stack[top--];
                stack[++top]=num1 + num2;
                break;
            
            case '-':
                num2 = stack[top--];
                num1 = stack[top--];
                stack[++top]=num1 - num2;
                break;

            case '*':
                num2 = stack[top--];
                num1 = stack[top--];
                stack[++top]=num1 * num2;
                break;  
            
            case '/':
                num2 = stack[top--];
                num1 = stack[top--];
                stack[++top]=num1 / num2;
                break;  
            
            default:
                stack[++top] =Integer.parseInt(str[i]);
                break;
            }
        }
        System.out.println(stack[top--]);
    }
}





저작자표시

'알고리즘' 카테고리의 다른 글

BufferedReader 로 입출력 속도 단축하기  (0) 2019.01.23
Queue -java  (0) 2019.01.23
후위 표현식 만들기 (stack) - java  (0) 2019.01.22

후위 표현식

후위 표현식을 만들기 위해서는 연산자의 순서 우선순위를 알아두면 좋다

3가지로 구분해서 외우면 편할거 같은데

icp 연산에서 ( 는 우선순위가 3이라 가장 높다 따라서 ( 들어갈때는 무조건 스택에 쌓으면 된다

다음 *, / 연산은 *,/ 만났을때만 꺼내고 나머지는 쌓는다

+,- 연산은 *,/,+,- 만났을때 꺼내고 나머지는 쌓는다

) 는 ( 만날때 까지 꺼내고 만약  stack[top]==( 면 ( 삭제하기 위해서  top을 한번더 빼준다.

마지막으로는 스택에 남은 모든 값들을 출력해주면 후위표현식이 만들어 진다.


* 진짜 개 꿀팁 -

후위 표현식을 만들고 계산을 해야하는데 나오는 값을 다른 배열에 넣지말고 

String a ="";

이런 문자열 하나 만들어서 그 뒤에 계속 문자열로 붙여주면 진짜 쉽게 만들 수 있다



/**
* 계산기 : 중위표현식 => 후위 표현식으로 변환해서 출력
* icp : in-coming priority
*
* isp : in-stack priority
*
* 숫자가 클수록 우선순위가 높다
*
* 토큰 isp icp 비교 ) ( 나올때 까지 꺼냄 * / 2 2 + - 1 1 ( 0 0 스택에 무조건 넣기
*
* input 피연산자, 연산자 합쳐서 13개 입력 ( 6 + 5 * ( 2 - 8 ) / 2 )
*
* output 6 5 2 8 - * 2 / +
*
*/


public class 후위연산만들기 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char[] stack = new char[20]; //연산자만 저장
        int top=-1;
        String[] str = sc.nextLine().split(" ");
        
        
        for(int i=0; i<str.length; i++) {
            char c =str[i].charAt(0);
            
            switch(c) {
            
            case '(': //들어가는 ( 괄호는 우선순위가 3이라 잴 높다 그래서 무조건 스택에 쌓는다
                stack[++top]=c;
                break;
            case '*': // *, / 는 우선순위가 2이다 스택에 나보다 우선순위가 작은것이 남아있을때 까지 출력한다
            case '/': // 여기서 *, / 보다 우선순위가 같거나 높은 경우는 *,/ 밖에 없다 그건 꺼내고 나머지는 쌓는다
                while(top>-1 &&(stack[top]== '*' || stack[top]=='/')) {
                    System.out.print(stack[top]+" ");
                    top--; //꺼낸다
                }
                stack[++top]=c;
                break;
                
            case '+': // + - 보다 우선순위가 낮은 경우는 없기 때문에 다 출력한다
            case '-':
                while(top>-1 && (stack[top]=='*' || stack[top]=='/' || stack[top]=='+' || stack[top]=='-')) {
                    System.out.print(stack[top]+" ");
                    top--;
                }
                
                stack[++top]=c;
                break;
            case ')': // ( 만날때 까지 출력한다.
                while(top > -1 && stack[top]!='(') {
                    System.out.print(stack[top]+" ");
                    top--;
                }
                if(stack[top]=='(') {
                    top--;
                }
                break;
            default:
                System.out.print(str[i]+" ");
                break;
            }

        }
        
        while(top > -1) {
            System.out.println(stack[top--]+" ");
        }
        
    }
}








저작자표시

'알고리즘' 카테고리의 다른 글

BufferedReader 로 입출력 속도 단축하기  (0) 2019.01.23
Queue -java  (0) 2019.01.23
후위 표현식 계산하기  (0) 2019.01.22

+ Recent posts

티스토리툴바