QStack.java

import weiss.nonstandard.*;

public class QStack implements Stack
{
      private Queue fullQueue;
      private Queue transferQueue;
      
      public QStack()
      {
         fullQueue = new ArrayQueue();
         transferQueue = new ArrayQueue();
      }
      
      public void push(Object newElement)
      {
         while (!fullQueue.isEmpty())
         {
            // Enqueue the elements in order (from a queue perspective)
            transferQueue.enqueue(fullQueue.dequeue());
         }

         fullQueue.enqueue(newElement);

         while (!transferQueue.isEmpty())
         {
            // Enqueue the elements in order (from a queue persepctive)
            fullQueue.enqueue(transferQueue.dequeue());
         }
      }
      
      public void pop()
      {
         fullQueue.dequeue();
      }
      
      public Object top()
      {
         return (fullQueue.getFront());
      }
      
      public Object topAndPop()
      {
         return (fullQueue.dequeue());
      }
      
      public boolean isEmpty()
      {
         return (fullQueue.isEmpty());
      }
      
      public void makeEmpty()
      {
         fullQueue.makeEmpty();
      }
}

SQueue.java

import weiss.nonstandard.*;

public class SQueue implements Queue
{
      private Stack fullStack;
      private Stack transferStack;
      
      public SQueue()
      {
         fullStack = new ArrayStack();
         transferStack = new ArrayStack();
      }
      
      public void enqueue(Object newElement)
      {
         while (!fullStack.isEmpty())
         {
            // Push the elements onto transferStack in reverse
            //   order (from a stack perspective)
            transferStack.push(fullStack.topAndPop());
         }

         // Put the new element at the end of the queue / bottom of the stack
         fullStack.push(newElement);

         while (!transferStack.isEmpty())
         {
            // Push all the elements back in reverse
            //   (of reverse = normal) order (from a stack perspective)
            fullStack.push(transferStack.topAndPop());
         }
      }
      
      public Object getFront()
      {
         return (fullStack.top());
      }
      
      public Object dequeue()
      {
         return (fullStack.topAndPop());
      }

      public boolean isEmpty()
      {
         return (fullStack.isEmpty());
      }
      
      public void makeEmpty()
      {
         fullStack.makeEmpty();
      }
}