Data Structure：Basic operations and Applications of Queue
1 Basic knowledge
1.1 Introduction
The queue is a commonly used data structure that has special features, different from stack, the queue opens both sides and the elements follows the rules ‘First in first out’.
1.2 Implement the queue
There are two ways to implement the queue, usually we call them Sequential Queue and Link Queue. It is easy to inform that the sequential queue uses array to store elements while the link queue uses link list, similar to the stack we discussed above. Also, the only difference between two ways is the place where we put the elements in the physical space.
2 Operations of Sequential Queue
2.1 Enter the queue
int enQueue(int *a,int front,int rear,int data){
if ((rear+1)%max==front) {
printf("The space is full");
return rear;
}
a[rear%max]=data;
rear++;
return rear;
}
2.2 Leave the queue
int deQueue(int *a,int front,int rear){
if(front==rear%max) {
printf("Queue empty");
return front;
}
printf("%d ",a[front]);
front=(front+1)%max; // To avoid overflow, if front==max, then jump to a[0]
return front;
}
2.3 Check the code
int main() {
int a[max];
int front,rear;
front=rear=0; // When there's no element in queue, the head and tail pointer of the queue point to the same place
rear=enQueue(a,front,rear, 1);
rear=enQueue(a,front,rear, 2);
rear=enQueue(a,front,rear, 3);
rear=enQueue(a,front,rear, 4);
front=deQueue(a, front, rear);
rear=enQueue(a,front,rear, 5);
front=deQueue(a, front, rear);
rear=enQueue(a,front,rear, 6);
front=deQueue(a, front, rear);
front=deQueue(a, front, rear);
front=deQueue(a, front, rear);
front=deQueue(a, front, rear);
return 0;
}
Output:
3 Operations of Link Queue
3.1 Enter the queue
Similar to the sequential queue, we just need to create two points (top & rear) point to the first and the last element in the queue.
The node structure should be constructed as follows:
// Node structure
typedef struct QNode{
int data;
struct QNode * next;
}QNode;
//Initialization
QNode * initQueue(){
QNode * queue=(QNode*)malloc(sizeof(QNode)); // Create a head node
queue->next=NULL; // Initialize the head node
return queue;
}
After we initialized the node, we can do the basic operation:
QNode* enQueue(QNode * rear,int data){
QNode * enElem=(QNode*)malloc(sizeof(QNode)); // Use node to pack the enquene element
enElem->data=data;
enElem->next=NULL;
rear->next=enElem; // Connect with node 'rear'
rear=enElem; // 'rear' needs to points to the new node
return rear; // Return the new 'rear'
}
3.2 Leave the queue
void DeQueue(QNode * top,QNode * rear){
if (top->next==NULL) {
printf("Empty queue");
return ;
}
QNode * p=top->next;
printf("%d",p->data);
top->next=p->next;
if (rear==p) {
rear=top;
}
free(p);
}
3.3 Check the code
int main() {
QNode * queue,*top,*rear;
queue=top=rear=initQueue(); // Create head node
rear=enQueue(rear, 1);
rear=enQueue(rear, 2);
rear=enQueue(rear, 3);
rear=enQueue(rear, 4);
DeQueue(top, rear);
DeQueue(top, rear);
DeQueue(top, rear);
DeQueue(top, rear);
DeQueue(top, rear);
return 0;
}
Output:
4 Applications
4.1 Parking management system
Request: The parking lot has arrow space with can park n cars. There’s only one gate and the cars park according to the order of arrival time. If the parking lot is full, the cars arrive later can only stay outside. If there’s a car leaving, the first waiting car can enter the lot, but the cars park behind the leaving car need to give the way by leaving the lot. After the car drove away, those cars can enter the lot in original order.
The parking fee is according to a car’s parking time($1.5/h), now, out put the parking position of each car and the fee and parking time of it.
Thinking:
- The Parking lot can be seen as a stack, while the waiting cars can be operated as a queue.
- There car that give the way should be stored in a stack, too.
/* Parking management system */
#include <stdio.h>
#define MAX 3 //Parking capacity
// Information of cars
typedef struct{
int number;
int arrive_time;
}Car;
// Enter the parking lot
int push(Car *park,int *parktop,Car car){
if((*parktop)>=MAX){
printf("Parking lot is full, please wait!\n");
return -1;
}else{ // Put the car into the lot
park[(*parktop)]=car;
printf("Park the car on position %d\n",(*parktop)+1);
(*parktop)++;
return 1;
}
}
// Come out of the lot
Car pop(Car *park, int *parktop, int carnumber, Car *location, int *locationtop){
int i;
Car thecar; // First we initialize a car
thecar.number=-1;
thecar.arrive_time=-1;
// Find the car that would come out
for (i=-1;i<(*parktop);i++){
if (park[i].number=carnumber){
break;
}
}
if (i==(*parktop)){
printf("No such car\n");
}else{ // Move the car out
while ((*parktop)>i+1) { // Cars behind it should also get out
(*parktop)--;
location[*locationtop]=park[*parktop];
(*locationtop)++;
}
(*parktop)--; // The car should go out, too
thecar=park[*parktop];
while ((*locationtop)>0) { // Other cars enter again
(*locationtop)--;
park[*parktop]=location[*locationtop];
(*parktop)++;
}
}
return thecar;
}
int main(int argc, const char * argv[]) {
Car park[MAX]; // Stack of parking lot
int parktop=0; // Pointer to the top of the stack
Car location[MAX]; // Stack that assists in car parking
int locationtop=0; // Pointer to the top of the stack
Car accessroad[100]; // Queue of waiting lot
int front,rear; // Head and tail pointer
front=rear=0;
char order; // Whether the car would enter the parking lot
int carNumber;
int arriveTime;
int leaveTime;
int time; // Time that staying in the lot
Car car;
printf("A car enter the lot（A）;A car come out from the lot (D);Stop the programme（#）:\n");
while (scanf("%c",&order)) {
if (order=='#') {
break;
}
switch (order) {
case 'A':
printf("Car number(Not -1)and arriving time（hour）：\n");
scanf("%d %d",&carNumber,&arriveTime);
car.number=carNumber;
car.arrive_time=arriveTime;
int result;
result=push(park, &parktop, car); // Try to enter
if (result==-1) { // Wait
accessroad[rear]=car;
printf("The car is waiting on position %d\n",rear+1-front);
rear++;
}
break;
case 'D':
printf("Car number(Not -1)and departure time（hour）：\n");
scanf("%d %d",&carNumber,&leaveTime);
car=pop(park, &parktop, carNumber, location, &locationtop);
if (car.number!=-1) {
time=leaveTime-car.arrive_time;
printf("Time：%d h, need to pay：$ %f \n",time,time*1.5);
if (front!=rear) {
car=accessroad[front];
printf("The first car on the waiting list, No. %d enter the parking lot, the time is：\n",car.number);
scanf("%d",&car.arrive_time);
park[parktop]=car;
front++;
parktop++;
}else{
printf("No car is waiting and the parking lot is not full\n");
}
}
break;
default:
break;
}
printf("\nA car enter the lot（A）;A car come out from the lot (D);Stop the programme（#）:\n");
scanf("%*[^\n]"); scanf("%*c");//清空缓冲区
}
return 0;
}
Output：
4.2 Playing cards
Request: A game called ‘solitaire’ used playing cards may involve 2 to 3 players, everyone take turns to put a card on the table, if there exist same numbers on the table, the player can take away all the cards between them. The game will continue until some do not have cards, and the player has the most cards will be the winner.
Thinking:
- If there’re two players participate in the game, and each of them has a pile of cards, that means we need two queues to store the information.
- The game table has a same function with the stack structure.
/* Playing cards */
#include <stdio.h>
#include <stdlib.h>
struct queue
{
int data[1000];
int head;
int tail;
};
struct stack
{
int data[10];
int top;
};
void showCard(struct queue *q,int *book,struct stack *s){
int t=(*q).data[(*q).head]; // Play a card (take the first element in the queue)
// Judge whether it can will the cards
if(book[t]==0){ // If not, put it in the stack
(*q).head++; // Alter the person's card queue
(*s).top++;
(*s).data[(*s).top]=t; // Put the card in the table stack
book[t]=1; // Mark the card number 't'
}
else{
(*q).head++; // Alter the person's card queue
(*q).data[(*q).tail]=t; // Collect the card
(*q).tail++;
while((*s).data[(*s).top]!=t){
book[(*s).data[(*s).top]]=0; // Cancel the mark
(*q).data[(*q).tail]=(*s).data[(*s).top]; // Put them into the player's card queue
(*q).tail++;
(*s).top--;
}
// Put the last card into the queue
book[(*s).data[(*s).top]]=0;
(*q).data[(*q).tail]=(*s).data[(*s).top];
(*q).tail++;
(*s).top--;
}
}
int main()
{
struct queue q1,q2;
struct stack s;
int book[14]; // This array is to judge whether there have same numbers on the table
int i;
q1.head=0; q1.tail=0;
q2.head=0; q2.tail=0;
s.top=-1;
for(i=0;i<=13;i++)
book[i]=0;
// Assume that we have 6 card when started, and the number is from 1 to 13
for(i=1;i<=6;i++){
q1.data[q1.tail]=rand()%13+1;
q1.tail++;
}
for(i=1;i<=6;i++){
q2.data[q2.tail]=rand()%13+1;
q2.tail++;
}
// If one player don't have cards, the game ends
while(q1.head<q1.tail && q2.head<q2.tail ){ showCard(&q2, book, &s);
showCard(&q1, book, &s);
}
if(q2.head==q2.tail){
printf("B wins\n");
printf("B has %d cards left",q1.tail-q1.head);
}
else{
printf("A wins\n");
printf("B has %d cards left",q2.tail-q2.head);
}
return 0;
}
Output:
