[JAVA] 백준 18258 큐 2

18258번: 큐 2 (acmicpc.net)

18258번: 큐 2

 

 

풀이 과정 

 

- Deque 인터페이스로 선언한 뒤 LinkedList로 생성하여 이용 

 

 

- push X = 정수 X를 큐에 넣는 연산

- pop =  큐에서 가장 앞에 있는 정수를 빼고, 그 수를 출력, 만약 큐에 들어있는 정수가 없는 경우에는 -1을 출력

- size = 큐에 들어 있는 정수의 개수를 출력

- empty = 큐가 비어 있으면 1, 아니면 0을 출력

- front = 큐의 가장 앞에 있는 정수를 출력, 만약 큐에 들어있는 정수가 없는 경우에는 -1을 출력

- back = 큐에 가장 뒤에 있는 정수를 출력. 만약 큐에 들어 있는 정수가 없는 경우에는 -1을 출력 

 

Deque (덱)

 

[Java] Deque (덱/데크) 사용법 및 예제 (tistory.com)

[Java] Deque (덱/데크) 사용법 및 예제

 

- 덱은 Double-Ended Queue의 줄임말로 큐의 양쪽에 데이터를 넣고 뺄 수 있는 형태의 자료구조를 의미 

- 하나의 자료구조에 큐(queue)와 스택(Stack)을 합쳐 놓은 형태 

- 덱의 앞쪽으로 데이터를 넣고 뒤쪽에서 빼면 큐처럼 사용 가능

- 덱의 앞쪽에 넣고 다시 앞쪽에서 빼면 스택처럼 사용 가능 

- 한쪽으로만 입력이 가능하도록 설정한 덱을 스크롤(Scroll)이라고 함 

- 한쪽으로만 출력할 수 있도록 설정한 덱을 셸프(Shelf)라고 함 

 

Deque 생성 

Deque<String> deque1 = new ArrayDeque<>();
Deque<String> deque2 = new LinkedBlockingDeque<>();
Deque<String> deque3 = new ConcurrentLinkedDeque<>();
Deque<String> linkedList = new LinekdList<>();

 

- Deque는 인터페이스로 구현되어 있음 

- Deque 자료구조의 여러 연산들은 Deque 인터페이스에 정의되어 잇음 

 

Deque 값 추가 

 

deque.addFirst(); //Deque의 앞쪽에 데이터를 삽입, 용량 초과 시 Exception
deque.offerFirst(); //Deque의 앞쪽에 데이터를 삽입 후 true, 용량 초과 시 false

deque.addLast(); //Deque의 뒤쪽에 데이터를 삽입, 용량 초과 시 Exception
deque.add(); //addLast()와 동일 
deque.offerLast(); //Deque의 뒤쪽에 데이터를 삽입 후 true, 용량 초과 시 Exception
deque.offer(); //offerLast()와 동일 

deque.push(); //addFrist()와 동일
deque.pop(); //removeFirst()와 동일

 

 

Deque 값 제거 

 

deque.removeFirst(); //Deque의 앞에서 제거, 비어있으면 예외 
deque.remove(); //removeFirst()와 동일
deque.poll(); //Deque의 앞에서 제거, 비어 있으면 null 리턴
deque.pollFirst(); //poll()과 동일 

deque.removeLast(); //Deque의 뒤에서 제거 , 비어 있으면 예외 
deque.pollLast(); //Deque의 뒤에서 제거, 비어 있으면 null 리턴

 

 

Deque에서 데이터를 찾아서 제거하는 메소드 

 

//Deque의 앞쪽에서 찾아서 첫 번째 데이터를 삭제 
deque.removeFirstOccurrence(Object o);

//Deque의 뒤쪽에서 찾아서 첫 번째 데이터를 삭제 
deque.removeLastOccurrence(Object o);

//removeFirstOccurrence() 메소드와 동일 
deque.remove(Object o);

 

 

Deque 값 확인 

 

deque.getFirst(); // 첫 번째 엘리먼트를 확인, 비어있으면 예외
deque.peekFirst(); // 첫 번째 엘리먼트를 확인, 비어있으면 null 리턴
deque.peek();// peekFirst()와 동일

deque.getLast(); // 마지막 엘리먼트를 확인, 비어있으면 예외
deque.peekLast();// 마지막 엘리먼트를 확인, 비어있으면 null 리턴

deque.contain(Object o); // Object 인자와 동일한 엘리먼트가 포함되어 있는지 확인
deque.size(); // Deque에 들어있는 엘리먼트의 개수

 

 

정답 

 

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;
import java.util.LinkedList;
import java.util.Deque;

public class Main {
    public static void main(String[] args) throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        
        Deque<Integer> queue = new LinkedList<>();
        
        int n = Integer.parseInt(br.readLine());
        
        for(int i=0; i<n; i++)
        {
            String s = br.readLine();
            StringTokenizer st = new StringTokenizer(s);
            
            switch(st.nextToken())
            {
                case "push":
                    queue.offer(Integer.parseInt(st.nextToken()));
                    break;
                    
                case "pop":
                    Integer e0 = queue.poll();
                    if(e0 == null)
                    {
                        bw.write(-1+"");
                        bw.newLine();
                    }
                    else
                    {
                        bw.write(e0+"");
                        bw.newLine();
                    }
                    
                case "size":
                    bw.write(queue.size()+"");
                    bw.newLine();
                    break;
                    
                case "empty":
                    if(queue.isEmpty())
                    {
                        bw.write(1+"");
                        bw.newLine();
                    }
                    else
                    {
                        bw.write(0+"");
                        bw.newLine();
                    }
                    break;
                    
                case "front":
                    Integer e1 = queue.peek();
                    if(e1==null)
                    {
                        bw.write(-1+"");
                        bw.newLine();
                    }
                    else
                    {
                        bw.write(e1+"");
                        bw.newLine();
                    }
                    break;
                    
                case "back":
                   Integer e2 = queue.peekLast();
                   if(e2==null)
                   {
                       bw.write(-1+"");
                       bw.newLine();
                   }
                    else
                    {
                        bw.write(e2+"");
                        bw.newLine();
                    }
                    break;
            }

        }
        
        bw.flush();
        bw.close();
    }
}