[JAVA] 백준 10845 : 큐

import java.io.*;
import java.util.StringTokenizer;

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));
        StringTokenizer st;
        NodeManager nodeManager = new NodeManager();

        int count = Integer.parseInt(br.readLine());

        for (int i = 0; i < count; i++) {
            st = new StringTokenizer(br.readLine());
            String command = st.nextToken();
            switch (command) {
                case "push": {
                    int order = Integer.parseInt(st.nextToken());
                    nodeManager.push(new QueueNode(order));
                    break;
                }
                case "pop": {
                    QueueNode popped = nodeManager.pop();
                    bw.write((popped == null ? -1 : popped.getValue()) + "\n");
                    break;
                }
                case "size": {
                    bw.write(nodeManager.getSize() + "\n");
                    break;
                }
                case "empty": {
                    bw.write((nodeManager.isEmpty() ? 1 : 0) + "\n");
                    break;
                }
                case "front": {
                    QueueNode front = nodeManager.peek();
                    bw.write((front == null ? -1 : front.getValue()) + "\n");
                    break;
                }
                case "back": {
                    if (nodeManager.isEmpty()) {
                        bw.write("-1\n");
                    } else {
                        bw.write(nodeManager.tail.getValue() + "\n");
                    }
                    break;
                }
                default:
                    break;
            }
        }

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

class QueueNode {
    private int value;
    QueueNode nextNode;

    public QueueNode(int value) {
        this.value = value;
        nextNode = null;
    }

    public int getValue() {
        return value;
    }

    public void setNextNode(QueueNode node) {
        this.nextNode = node;
    }

    public QueueNode getNextNode() {
        return nextNode;
    }
}

class NodeManager {
    QueueNode head, tail;
    private int size;

    public NodeManager() {
        size = 0;
        head = tail = null;
    }

    public int getSize() {
        return size;
    }

    public boolean isEmpty() {
        return head == null;
    }

    public QueueNode pop() {
        if (isEmpty()) return null;
        QueueNode node = head;
        if (head.getNextNode() == null) {
            head = tail = null;
        } else {
            head = head.getNextNode();
        }
        size--;
        return node;
    }

    public void push(QueueNode node) {
        if (isEmpty()) {
            head = tail = node;
        } else {
            tail.setNextNode(node);
            tail = node;
        }
        size++;
    }

    public QueueNode peek() {
        if (isEmpty()) return null;
        return head;
    }
}