Question

Q1. Add the following operation to the class stackType: void reverseStack (stackType<Type> &otherStack); This operation copies the elements of a stack in reverse order onto another stack. Consider the following statements: stackType<int> stackl; stackType<int> stack2; The statement stackl.reverseStack (stack2); copies the elements of stackl onto stack2 in reverse order. That is, the top element of stackl is the bottom element of stack2, and so on. The old contents of stack2 are destroyed and stack1 is unchanged. Write the definition of the function template to implement the operation reverseStack. Also write the main() function to test your program. Note: You need to create a stackType class (discussed in Chapter 7) with the basic operations needed to fulfil this question, for example, you may remove unnecessary functions from this class which are not used in this question. Q2. The implementation of a queue in an array, as given in Chapter 8, uses the variable count to determine whether the queue is empty or full. On the other hand, class linkedQueue Type does not use such a variable to keep track of the number of elements in the queue. Redefine the class linkedQueue Type by adding the variable count to keep track of the number of elements in the queue. Modify the definitions of the functions addQueue and deleteQueue as necessary. Add the function queueCount to return the number of elements in the queue. Also, write a program to test various operations of the class you defined.

Answer 1

Q-1
public class Main<T> {

private T data[];
private int top; // is the index of topmost element of stack

public Main(int capacity) {
data = (T[]) new Object[capacity];
top = -1;
}
public boolean isEmpty(){ //isEmpty Method
return (top == -1);
}
public int size(){ //size Method
return top + 1;
}
public T top() { //Top method
return data[top];
}
public void push(T elem) { //push Method
if(size()==data.length){
System.out.println(("Stack is full. Increasing the capacity."));
doubleCapacity();
}
top++;
data[top] = elem;
}
private void doubleCapacity() { //doubleCapacity Method
       T temp[] = data;
       data = (T[]) new Object[2 * temp.length];
       for(int i = 0; i <= top; i++){
           data[i] = temp[i];
       }
      
   }

public T pop() throws Exception { //pop Method
if(this.isEmpty()){
throw new Exception("Stack is empty.");
}
T temp = data[top];
top--;
return temp;

}
public void reverseStack(Main stack2)throws Exception { //reverseStack Method from stack1 to stack2
if(this.isEmpty()){
throw new Exception("Stack is empty.");
}
while(!this.isEmpty()){
stack2.push(this.pop());
}
}
public static void main(String[] args)throws Exception { //Main
Main<Integer> stack1= new Main<Integer>(20);   
for(int i = 1; i <= 20; i++){
stack1.push(i); //push 20 element into stack1
}
System.out.println("=====Stack1======");
if(stack1.isEmpty()){
throw new Exception("Stack is empty.");   
}
while(!stack1.isEmpty()){
System.out.println(stack1.pop()); //pop 20 element from stack1
}
for(int i = 1; i <= 20; i++){
stack1.push(i);
}

Main<Integer> stack2 =new Main<Integer>(20);
stack1.reverseStack(stack2);
System.out.println("=====Stack2======");
while(!stack2.isEmpty()){
System.out.println(stack2.pop()); //pop 20 element from stack2
}

}

}

OUTPUT:

=====Stack1====== 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 =====Stack2====== 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20