Question

how do I change my code to generic form

***********************************************************************

public class UnboundedStackQueue { //question#3
}

class Stack
{
Node head;
int size;

Stack() //default constructor
{
this.head=null;
this.size=0;
}

//Input = data
//Output = void (just adds value to list)
// method pushes elements on stack
// time: O(1)
// space: O(1)
public void push(int data)
{
Node node=new Node(data);
node.next=head;
head=node;
size++;
}

//Input = none
//Output = top of stack
// method pops value from top of stack
// time: O(1)
// space: O(1)
public int pop()
{
if(head==null)
return -1;
size--;
int value=head.data;
head=head.next;
return value;
}

//Input = none
//Output = top of stack or last value added to stack
// method returns top of stack
// time: O(1)
// space: O(1)
public int peek()
{
if(head==null)
return -1;
return head.data;
}

//Input = none
//Output = true or false depending on if head is null or not
// method that says whether the stack is empty or not
// time: O(1)
// space: O(1)
public boolean isEmpty()
{
return head==null;
}

//Input = none
//Output = int representing number of elements in stack
// method that returns the size of stack
// time: O(1)
// space: O(1)
public int size()
{
return size;
}
}

class Node
{
int data;
Node next;
Node(int data)
{
this.data=data;
this.next=null;
}
}

class QueuesFromStacks
{
Stack s1,s2;

QueuesFromStacks() // constructor initializes two stacks
{
s1=new Stack();
s2=new Stack();
}

//Input = send in and int representing the value to be added
//Output = none; element just added to list
// method that enqueues value into queue. Here we just add push the value into s1
// time: O(1)
// space: O(1)
public void enqueue(int value)
{
s1.push(value);
}

//Input = none;
//Output = number from front of queue or first added number
// method that dequeues value from queue.
// time: O(n)
// space: O(1)
public int dequeue()
{
if(isEmpty())
return -1;
if(!s2.isEmpty())
{
int value=s2.pop();
return value;
}
while(!s1.isEmpty())
s2.push(s1.pop());
int value=s2.pop();
return value;
}

//Input = none;
//Output = returns element in front of list without removing it
// method that returns the top most value of queue
// time: O(n)
// space: O(1)
public int peek()
{
if(isEmpty())
return -1;
if(!s2.isEmpty())
return s2.peek();
while(!s1.isEmpty())
s2.push(s1.pop());
return s2.peek();
}

//Input = none
//Output = true or false depending on if empty
// method that says whether the queue is empty or not
// time: O(1)
// space: O(1)
public boolean isEmpty()
{
return s1.isEmpty() && s2.isEmpty();
}

//Input = none
//Output = total size (which must add both stacks)
// method that returns size of queue
// time: O(1)
// space: O(1)
public int size()
{
return s1.size()+s2.size();
}
}
class Main
{

public static void main(String args[])
{
QueuesFromStacks queueTest =new QueuesFromStacks();
for(int i=1;i<=5;i++)
queueTest.enqueue(i);
while(!queueTest.isEmpty())
System.out.print(queueTest.dequeue()+" ");
System.out.println();
}
}

****************************************************************

Answer 1

Hi. I have answered the same question (QueuesFromStacks) before. Here is the completed code for this problem. Comments are included, go through it, learn how things work and let me know if you have any doubts or if you need anything to change. If you are satisfied with the solution, please rate the answer. If not, PLEASE let me know before you rate, I’ll help you fix whatever issues. Thanks

Make sure you copy below classes into separate files as mentioned. Do not copy everything to a single file.

//QueuesFromStacks.java

public class QueuesFromStacks<E> {

      // declaring two stacks. please find Stack.java at the end of this code.

      private Stack<E> s1, s2;

      // constructor initializing both stacks

      public QueuesFromStacks() {

            s1 = new Stack<E>();

            s2 = new Stack<E>();

      }

      // adds an element to the end of the queue

      public void enqueue(E item) {

            // moving all elements from s1 to s2

            while (!s1.isEmpty()) {

                  s2.push(s1.pop());

            }

            // adding item to s1

            s1.push(item);

            // moving all items from s2 back into s1

            while (!s2.isEmpty()) {

                  s1.push(s2.pop());

            }

      }

      // removes and returns front element

      public E dequeue() {

            if (isEmpty()) {

                  return null;

            }

            return s1.pop();

      }

      // returns front element

      public E peek() {

            if (isEmpty()) {

                  return null;

            }

            return s1.peek();

      }

      // returns true if stack is empty, false if not

      public boolean isEmpty() {

            return size() == 0;

      }

      // returns the size

      public int size() {

            return s1.size();

      }

      // main method for testing, you may move this into Main.java class if you want.

      public static void main(String[] args) {

            // creating a queue of integers, adding numbers from 1 to 5

            QueuesFromStacks<Integer> q = new QueuesFromStacks<Integer>();

            for (int i = 1; i <= 5; i++) {

                  q.enqueue(i);

            }

            // dequeuing 3 values and displaying

            System.out.println(q.dequeue()); // 1

            System.out.println(q.dequeue()); // 2

            System.out.println(q.dequeue()); // 3

            // adding 6

            q.enqueue(6);

            System.out.println(q.dequeue()); // 4

            // adding 7

            q.enqueue(7);

            // removing and displaying remaining values. should print values fro 5

            // to 7

            while (!q.isEmpty()) {

                  System.out.println(q.dequeue());

            }

      }

}

//Stack.java

public class Stack<E> {

      private Node<E> top;

      private int size;

      public Stack() {

            top = null;

            size = 0;

      }

     

      //adds an element to the top

      public void push(E element) {

            Node<E> n = new Node<E>(element);

            n.next = top;

            top = n;

            size++;

      }

     

      //removes and returns top element

      public E pop() {

            if (isEmpty()) {

                  return null;

            }

            E item = top.item;

            top = top.next;

            size--;

            return item;

      }

     

      //returns top element

      public E peek() {

            if (isEmpty()) {

                  return null;

            }

            return top.item;

      }

      // returns true if queue is empty, false if not

      public boolean isEmpty() {

            // queue is empty if front is null

            return size == 0;

      }

     

      //returns the size

      public int size() {

            return size;

      }

      // a class to represent the Node

      class Node<E> {

            // making data and next fields public, so that we can easily access them

            // without methods

            public E item;

            public Node<E> next;

            // constructor taking initial value for data

            public Node(E d) {

                  item = d;

                  next = null;

            }

      }

}

/*OUTPUT*/

1

2

3

4

5

6

7