queue

Queue, also known as queue, is a linear table of FIFO, First-In-First-Out. In specific applications, it is usually implemented with linked lists or arrays. The queue only allows insert operations at the back end (called rear) and delete operations at the front end (called front).
The operation of the queue is similar to that of the stack. The only difference is that the queue only allows new data to be added in the backend.
-Source: Wikipedia

3.1 Definition of queue

element follows first-in-first-out (similar to the situation of queuing in supermarkets in life)
The operation of element satisfies: enter the queue from the end of the line, leave the queue from the head of the line

template<typename DataType>class Queue
{
public:
	Queue(int size)
	{
		maxSize = size;
		front = 0;
		rear = 0;
		count = 0;
		elements = new DataType[maxSize];
		//If space allocation fails, exit the program directly
		if(elements==NULL)
			exit(1);
	}
	~Queue()
	{
		delete [] elemenets;
	}
	bool insert(DataType data);
	DataType pop();
	bool isempty();
	bool isfull();
	DataType getF();
	DataType getR();
private:
	int count;
	int maxSize;
	int front;//The top position of the team
	int rear;//The tail position
	DataType *elements;
};

3.2 Basic operation

The basic operations of the queue include entering the team, leaving the team, judged empty, judged full, return to the head element, and return to the end element;

3.2.1 Enrollment operation

template<typename DataType>bool Queue<DataType>::insert(DataType data)
{
	if(count==maxSize)
		return false;
	elements[rear]=data;
	rear=(rear+1)%maxSize;//Circular queue, save space
	count++;
	return true;
}

3.2.2 Dequeue operation

template<typename DataType>DataType Queue<DataType>::pop()
{
	if(count==0)
		exit(1);
	DataType temp=elements[front];
	front=(front+1)%maxSize;
	count--;
	return temp;
}

3.2.3 Empty operation

template<typename DataType>bool Queue<DataType>::isempty()
{
	if(count==0)return true;
	return false;
}

3.2.4 Full operation

template<typename DataType>bool Queue<DataType>::isfull()
{
	if(count==maxSize)return true;
	return false;
}

3.2.5 Return to the top element

template<typename DataType>DataType Queue<DataType>::getF()
{
	if(count==0)
		exit(1);
	return elements[front];
}

3.2.6 Return to the tail element

template<typename DataType>DataType Queue<DataType>::getR()
{
	if(count==0)
		exit(1);
	return elements[rear];
}

Questions

Without considering the complexity of the program, how do you use the stack to implement queue operations?

answer:
The characteristic of the stack is first-in-last-out (FILO)
The queue is characterized by first in first out (FIFO)
The first-in-last-out feature of the stack has been changed to realize the first-in-first-out of elements
Set up two stacks, one is responsible for the enqueue operation, when you want to leave the queue, the elements in the stack of the enqueue operation will be popped out of the stack, and once into the second stack, then the second stack will be queued Popping, that is, after dequeuing, the elements in the second stack are returned to the first stack

Reference book "Interesting Algorithm (C++ Language Implementation)"