Question

(java)

Please implement your own Dequeue class which has following methods

•boolean add(E e)= void addLast(E e)  // two methods are the same. You could implement either one

•

•void addFirst(E e)

•

•E getFirst( ) = E peek( ) // two methods are the same. You could implement either one

•E getLast( )

•E removeFirst()

•E removeLast()

Case 1 : Queue

•Create a queue which is an instance of Dequeue. The queue should perform with given following input and print the correct output.

•Input format

•The first line contains an integer of q :

•q specifies the number of queries which follows in the next lines

•Each of the q next  lines contains a single query in the form of one of following 3 types :

•1 x: Enqueue element  into the end of the queue.

•2: Dequeue the element at the front of the queue.

•3: Print the element at the front of the queue.

Case 2. Stack

•Create a a stack which is an instance of Dequeue. The stack should perform with given following input and print the correct output.

•Input format

•Any string of postfix expression

•Example “34+78+*”

•Output

•The value of evaluation

•105

Answer 1

Program:

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

//Dequeue class
class Dequeue<E>
{
   //data members
   private int first;
   private int last;
   private int size;
   private E dq[];
   //static data members
   static int MAX = 10;
  
   //constri=uctor
   public Dequeue()
   {
       first = -1;
       last = -1;
       size = 0;
       dq = (E[]) new Object[MAX];
   }
  
   //add an item to the last
   void addLast(E e) throws IOException
   {
       if(size==MAX)
           throw new IOException();
      
       size++;
       if(last==-1)
       {
           first = last = 0;
       }
       else
           last = (last+1)%size;
       dq[last] = e;
   }
   //add an item to the first
   void addFirst(E e) throws IOException
   {
       if(size==MAX)
           throw new IOException();
      
       size++;
       if(first==-1)
       {
           first = last = 0;
       }
       else if (first == 0)
first = size-1;
else
   first = first-1;
  
dq[first] = e;
   }
   //return an item from the first
   E getFirst() throws IOException
   {
       if(size==0)
           throw new IOException();
      
       return dq[first];
   }
   //return an item from the last
   E getLast() throws IOException
   {
       if(size==0)
           throw new IOException();
      
       return dq[last];
   }
   //remove an item from the first
   E removeFirst() throws IOException
   {
       if(size==0)
           throw new IOException();
       E item = dq[first];;
      
       if(first==last)
       {
           first = last = -1;
       }
       else if(first == size-1)
       {
           first=0;
       }
       else
           first= first +1;
          
       return item;
   }
   //remove an item from the last
   E removeLast() throws IOException
   {
       if(size==0)
           throw new IOException();
       E item = dq[last];;
      
       if(first==last)
       {
           first = last = -1;
       }
       else if(last == 0)
       {
           last = size-1;
       }
       else
           last = last-1;
          
       return item;
   }
}

//class Tester
class Tester
{
   //method to test case 1 for queue operations
   static void queueCaseOne() throws IOException
   {
       //create a queue
       Dequeue<Integer> queue = new Dequeue<Integer>();
       //create an instance of Scanner class
       Scanner sc = new Scanner(System.in);
      
       //number of queries
       System.out.println ("Enter number of queries");
       int q = sc.nextInt();
      
       //execute q number of queries
       for(int i=0; i<q; i++)
       {
           System.out.println ("1. Enqueue element into the end of the queue.");
           System.out.println ("2. Dequeue the element at the front of the queue.");
           System.out.println ("3. Print the element at the front of the queue.");
           int op = sc.nextInt();
          
           int x;
           switch(op)
           {
               case 1:
                   x = sc.nextInt();
                   queue.addLast(x);
                   break;
               case 2:
                   x = queue.removeFirst();
                   System.out.println (x + " is removed");
                   break;
               case 3:
                   x = queue.getFirst();
                   System.out.println ("The element at the front is " + x);
                   break;
           }
       }
   }
   //method to test case 2 for stack operations
   static void stackCaseTwo() throws IOException
   {
       //create a stack
       Dequeue<Integer> stack = new Dequeue<Integer>();
      
       //postfix expression
       String postfix = "34+78+*";
      
       //evaluate postfix expression using stack
       for(int i=0; i<postfix.length(); i++)
       {
           char ch = postfix.charAt(i);
          
           //check for operand
           if(Character.isLetterOrDigit(ch))
           {
               stack.addLast(ch - '0');
           }
           //when operator found
           else
           {
               //pop two items from the stack
               int y = stack.removeLast();
               int x = stack.removeLast();
               //perform operation
               switch(ch)
               {
                   case '+': stack.addLast(x+y);
                               break;
                   case '-': stack.addLast(x-y);
                               break;
                   case '*': stack.addLast(x*y);
                               break;
                   case '/': stack.addLast(x/y);
                               break;
               }
              
           }
       }
       //display the output
       System.out.println ("Output = " + stack.removeLast());
   }
  
   //main method
   public static void main (String[] args) throws IOException
   {
       System.out.println ("Test case 1 for queue operations:\n");
       queueCaseOne();
       System.out.println ("\n\nTest case 2 for stack operations:\n");
       stackCaseTwo();
   }
}

Output:

Test case 1 for queue operations:

Enter number of queries
5
1. Enqueue element into the end of the queue.
2. Dequeue the element at the front of the queue.
3. Print the element at the front of the queue.
1 5
1. Enqueue element into the end of the queue.
2. Dequeue the element at the front of the queue.
3. Print the element at the front of the queue.
1 7
1. Enqueue element into the end of the queue.
2. Dequeue the element at the front of the queue.
3. Print the element at the front of the queue.
3
The element at the front is 5
1. Enqueue element into the end of the queue.
2. Dequeue the element at the front of the queue.
3. Print the element at the front of the queue.
2
5 is removed
1. Enqueue element into the end of the queue.
2. Dequeue the element at the front of the queue.
3. Print the element at the front of the queue.
2
7 is removed

Test case 2 for stack operations:

Output = 105