Question

Develop a generic stack ADT class by once again implementing the StackInterface.java and use Queue object as underlying ADT(implement stack using queue)

Include two constructors: one that sets the capacity at 100 elements, and the other that allows the application level to provide a capacity value as an actual parameter with the constructor call.

Also include a toString method.

StackInterface :

package interfaces;

public interface StackInterface<E> {

void push(E element); // add an element to the stack - always at the "top"

E pop(); // remove and return the top of the stack

E peek(); // return the top of the stack ... without removing

boolean isEmpty();

boolean isFull();

}

Answer 1

Hi, I have answered this question 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. Thanks

EDIT: included Queue implementation (using two stacks) also, and a Test class for testing.

// Stack.java

package adts;

import interfaces.StackInterface;

public class Stack<T> implements StackInterface<T> {

      // an ArrayQueue object as underlying structure

      private ArrayQueue<T> queStack;

      // default constructor, initializes capacity to 100

      public Stack() {

            queStack = new ArrayQueue<T>(100);

      }

      // constructor taking initial capacity

      public Stack(int capacity) {

            queStack = new ArrayQueue<T>(capacity);

      }

      @Override

      public void push(T element) {

            // finding current size

            int size = queStack.numElements;

            // adding at the end

            queStack.enqueue(element);

            // now removing all elements upto the last element and adding to the

            // end, making last element first

            for (int i = 0; i < size; i++) {

                  queStack.enqueue(queStack.dequeue());

            }

      }

      @Override

      public T pop() {

            // just removing and returning last element of queue (top element of

            // stack)

            return queStack.dequeue();

      }

      @Override

      public T peek() {

            if (isEmpty())

                  return null;

            // since there is no front() method defined in ArrayQueue, we have to

            // return the element at queStack.front index

            return queStack.queue[queStack.front];

      }

      @Override

      public boolean isEmpty() {

            return queStack.isEmpty();

      }

      @Override

      public boolean isFull() {

            return queStack.isFull();

      }

      @Override

      public String toString() {

            String stackString = "Stack: (top)[";

            int size = queStack.numElements;

            //appending all values to a String

            for (int i = 0; i < size; i++) {

                  //removing last element from queue (top of stack)

                  T item = queStack.dequeue();

                  stackString += item;

                  //adding to end

                  queStack.enqueue(item);

                  if (i != size - 1) {

                        stackString += ", ";

                  }

            }

            stackString += "]";

            return stackString;

      }

}

// Queue.java

package adts;

import interfaces.QueueInterface;

public class Queue<T> implements QueueInterface<T> {

      // two ArrayStack objects as underlying datastructures

      private ArrayStack<T> stk1;

      private ArrayStack<T> stk2;

      // default constructor

      public Queue() {

            stk1 = new ArrayStack<T>(100);

            stk2 = new ArrayStack<T>(100);

      }

      // constructor taking capacity

      public Queue(int capacity) {

            stk1 = new ArrayStack<T>(capacity);

            stk2 = new ArrayStack<T>(capacity);

      }

      @Override

      public void enqueue(T element) {

            // removing all values from stk1 and adding to stk2

            while (!stk1.isEmpty()) {

                  stk2.push(stk1.pop());

            }

            // adding new element to stk1

            stk1.push(element);

            // removing all elements from stk2 to stk1

            while (!stk2.isEmpty()) {

                  stk1.push(stk2.pop());

            }

      }

      @Override

      public T dequeue() {

            if (isEmpty())

                  return null;

            // just removing and returning the top element of stk1, which is the

            // front element of this queue

            return stk1.pop();

      }

      @Override

      public boolean isEmpty() {

            // queue is empty if stk1 is empty

            return stk1.isEmpty();

      }

      @Override

      public boolean isFull() {

            // queue is full if stk1 is full

            return stk1.isFull();

      }

      @Override

      public String toString() {

            String queStr = "Queue: (front)[";

            // looping until stk1 is empty

            while (!stk1.isEmpty()) {

                  // popping and appending each value to string

                  T item = stk1.pop();

                  queStr += item;

                  if (!stk1.isEmpty()) {

                        queStr += ", ";

                  }

                  // adding to stk2

                  stk2.push(item);

            }

            // now removing all elements from stk2 to stk1

            while (!stk2.isEmpty()) {

                  stk1.push(stk2.pop());

            }

            queStr += "]";

            return queStr;

      }

}

// Test.java

package adts;

public class Test {

      public static void main(String[] args) {

            //testing both new classes

            System.out.println("Testing Stack\n");

            Stack<Integer> stk = new Stack<Integer>();

            for (int i = 0; i < 10; i++) {

                  stk.push(i);

            }

            System.out.println(stk);

            while (!stk.isEmpty()) {

                  System.out.println(stk.pop() + " is popped");

            }

            System.out.println("\n\nTesting Queue\n");

            Queue<Integer> que = new Queue<Integer>();

            for (int i = 0; i < 10; i++) {

                  que.enqueue(i);

            }

            System.out.println(que);

            while (!que.isEmpty()) {

                  System.out.println(que.dequeue() + " is dequed");

            }

      }

}

/*OUTPUT*/

Testing Stack

Stack: (top)[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

9 is popped

8 is popped

7 is popped

6 is popped

5 is popped

4 is popped

3 is popped

2 is popped

1 is popped

0 is popped

Testing Queue

Queue: (front)[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

0 is dequed

1 is dequed

2 is dequed

3 is dequed

4 is dequed

5 is dequed

6 is dequed

7 is dequed

8 is dequed

9 is dequed