Implement Queue using Stacks

Implement a first in first out (FIFO) queue using only two stacks. The implemented queue should support all the functions of a normal queue.

Example:

enQueue(1): : isEmpty(): 0: front() : 1 Size() : 
ront(): : isEmpty(): 0: deQueue() : 1: Size() : 
front(): Underflow!!-1: isEmpty(): 1: deQueue() : Underflow!!-1: Size() : 
enQueue(1): : isEmpty(): 0: front() : 1 Size() : 
enQueue(2): : isEmpty(): 0: front() : 1: Size() : 2
enQueue(3): : isEmpty(): 0: front() : 1: Size() : 3
enQueue(4): : isEmpty(): 0: front() : 1: Size() : 4

Approach

Java

import java.util.Stack;

public class ImplQueuesUsingStack {
    public static void main(String[] args) {
        QueueStack<Integer> s = new QueueStack<>();

        // push 1 element
        System.out.println("enQueue(1): " + s.enQueue(1) + 
        ": isEmpty(): " + s.isEmpty() + ": front() : " + s.front()
                + ": Size() : " + s.size());
        // pop element
        System.out.println("front(): " + s.front() + 
        ": isEmpty(): " + s.isEmpty() + ": deQueue() : " + s.deQueue()
                + ": Size() : " + s.size());
        // pop element
        System.out.println("front(): " + s.front() + ": isEmpty(): " 
                + s.isEmpty() + ": deQueue() : " + s.deQueue()
                + ": Size() : " + s.size());
        // push another element
        System.out.println("enQueue(1): " + s.enQueue(1) + ": isEmpty(): " 
        + s.isEmpty() + ": front() : " + s.front()
                + ": Size() : " + s.size());
        // push another element
        System.out.println("enQueue(2): " + s.enQueue(2) + ": isEmpty(): " 
                + s.isEmpty() + ": front() : " + s.front()
                + ": Size() : " + s.size());
        // push another element
        System.out.println("enQueue(3): " + s.enQueue(3) + ": isEmpty(): " 
            + s.isEmpty() + ": front() : " + s.front()
                + ": Size() : " + s.size());
        // push another element
        System.out.println("enQueue(4): " + s.enQueue(4) + ": isEmpty(): " 
            + s.isEmpty() + ": front() : " + s.front()
                + ": Size() : " + s.size());

    }
}

class QueueStack<T> {
    Stack<T> s1, s2;

    public QueueStack() {
        s1 = new Stack<>();
        s2 = new Stack<>();
    }

    // add value in queue
    boolean enQueue(T val) {
        // move all the item from s1 to s2
        while (!s1.isEmpty()) {
            s2.add(s1.pop());
        }
        s1.add(val);
        // move all back item from s2 to s1
        while (!s2.isEmpty()) {
            s1.add(s2.pop());
        }

        return true;
    }

// get front and front remove element from queue
    T deQueue() {
        if (s1.isEmpty()) {
            System.out.println("Underflow!!");
            System.exit(0);
        }
        return s1.pop();
    }

    // only get front element from queue
    T front() {
        if (s1.isEmpty()) {
            System.out.println("Underflow!!");
            System.exit(0);
        }
        return s1.peek();
    }

    public int size() {
        return s1.size();
    }

    boolean isEmpty() {
        return s1.isEmpty();
    }

}

C++

#include <bits/stdc++.h>
using namespace std;

class QueueStack
{
    public:
    stack<int> s1, s2;

     QueueStack() {
    }

    // add value in queue
    void enQueue(int val) {
        // move all the item from s1 to s2
        while (!s1.empty()) {
            s2.push(s1.top());
            s1.pop();
        }
        s1.push(val);
        // move all back item from s2 to s1
        while (!s2.empty()) {
            s1.push(s2.top());
            s2.pop();
        }
    }

// get front and front remove element from queue
    int  deQueue() {
        if (s1.empty()) {
            cout<<"Underflow!!";
            return -1;
        }
        int temp=s1.top();
        s1.pop();
        return temp;

    }

    // only get front element from queue
     int front() {
        if (s1.empty()) {
            cout<<"Underflow!!";
            return -1;
        }
        return s1.top();
    }

     int size() {
        return s1.size();
    }

    bool isEmpty() {
        return s1.empty();
    }

};
int main()
{
    QueueStack  s ;

        // push 1 element
        cout<<"enQueue(1): ";
        s.enQueue(1); 
        cout<<": isEmpty(): "<<s.isEmpty();
        cout<<": front() : "<<s.front();
        cout<< ": Size() : " + s.size()<<endl;
        // pop element
        cout<<"front(): " + s.front(); 
        cout<<": isEmpty(): "<<s.isEmpty();
        cout<<": deQueue() : "<<s.deQueue();
        cout<<": Size() : " + s.size()<<endl;
        // pop element
        cout<<"front(): "<<s.front();
        cout<<": isEmpty(): "<<s.isEmpty();
        cout<<": deQueue() : "<<s.deQueue();
        cout<<": Size() : " + s.size()<<endl;
        // push another element
        cout<<"enQueue(1): ";
        s.enQueue(1);
        cout<<": isEmpty(): "<<s.isEmpty();
        cout<<": front() : "<<s.front();
        cout<<": Size() : " + s.size()<<endl;
        // push another element
        cout<<"enQueue(2): ";
        s.enQueue(2);
        cout<<": isEmpty(): "<<s.isEmpty();
        cout<<": front() : "<<s.front();
        cout<<": Size() : "<<s.size()<<endl;
        // push another element
        cout<<"enQueue(3): ";
        s.enQueue(3);
        cout<<": isEmpty(): " <<s.isEmpty();
        cout<<": front() : "<<s.front();
        cout<<": Size() : "<<s.size()<<endl;
        // push another element
        cout<<"enQueue(4): ";
        s.enQueue(4);
        cout<<": isEmpty(): "<<s.isEmpty();
        cout<<": front() : "<<s.front();
        cout<<": Size() : "<<s.size()<<endl;
        return 0;

}