import java.util.Scanner;

interface Queue {
   public Object dequeue();
   public void enqueue(Object x);
   public boolean empty();
   public int size();
}

class ListAdapterQueue implements Queue {
   private LinkedList l;
   public ListAdapterQueue() {
      l = new LinkedList();
   }
   public int size() {
      return l.size();
   }
   public boolean empty() {
      return l.isEmpty();
   }
   public void enqueue(Object d) {
      l.addTail(d);
   }
   public Object dequeue() {
      return l.removeHead();
   }
   public String toString() {
      return l.toString();
   }
   public static void main(String args[]) {
      Queue q = new ListAdapterQueue();
      ArrayQueue.testQueue(q);
   }
}

class ArrayQueue implements Queue
{
   private Object data[];
   private int front, rear, size, capacity;

   public ArrayQueue() {
       capacity = 1000;
       data = new Object[capacity];
       front = rear = size = 0;
   }
    
   public ArrayQueue(int c) {
       capacity = c;
       data = new Object[capacity];
       front = rear = size = 0;
   }

   public int size() {
      return size;
   }
    
   public boolean empty() {
       return size == 0;
   }
    
   public void enqueue(Object x) {
       if (size() == capacity) 
          throw new RuntimeException("Queue Full");
       data[rear++] = x;
       if (rear == capacity) rear = 0;
       size ++;
   }
    
   public Object dequeue() {
       if (empty()) throw new RuntimeException("Queue Empty");
       Object answer = data[front++]; 
       if (front == capacity) front = 0;
       size --;
       return answer;
   }                      

// methods for testing purposes
   public String toString() {
      int i, j;
      String ans = "Array Queue:  ";
      for (i = 0, j = front; i< size; i++, j++) {
         if (j == capacity) j = 0;
         ans += ( data[j] + " -> ");
      }
      return ans;
   }
   public static void main(String args[]) {
      Queue q = new ArrayQueue();
      testQueue(q);
   }
   public static void testQueue(Queue q) {
      boolean done = false;
      while (!done) {
         try {
           Scanner sc = new Scanner(System.in);
           System.out.print( q + "  ");
           System.out.println("\ncmds are + - Q: >>");
           String cmd = sc.next();
           String entry = null;
           char command = cmd.charAt(0);
           if (command == '+') entry = sc.next();
           switch (cmd.charAt(0)) {
              case 'Q': done = true; break; 
              case '+': q.enqueue(entry); break;
              case '-': q.dequeue(); break;
           }
        } catch (Exception e) {
           System.out.println("Error " + e.toString());
        }
      }   
   }
}

class Node {
   private Object data;
   private Node next;
   public Node(Object x, Node n) { data = x; next = n; }
   public Object getData() { return data; }
   public Node getNext() { return next; }
   public void setData(Object x) { data = x; }
   public void setNext(Node n) { next = n; }
}

class LinkedQueue implements Queue
{
   protected Node front, rear;
   private int size;
   public LinkedQueue() { 
      front = rear = null; 
      size = 0; 
   }
   public int size() { 
      return size; 
   }
   public boolean empty() { 
      return size == 0; 
   }
   public Object dequeue() {
       if (empty()) throw new RuntimeException();
       Object answer = front.getData();
       front = front.getNext();
       size--;
       if (front == null) rear = front;
       return answer;
   }
   public void enqueue(Object x) {
       Node newRear = new Node(x, null);
       if (rear != null) rear.setNext(newRear);
       else front = newRear;
       rear = newRear;
       size++;
   }
   public String toString() {
      String ans = "Linked Queue:  ";
      Node n = front;
      while (n != null) {
         ans += ( n.getData() + " -> ");
         n = n.getNext();
      }
      return ans;
   }
   public static void main(String args[]) {
      Queue q = new LinkedQueue();
      ArrayQueue.testQueue(q);
   }
}