Queues

Queues are a FIFO (first-in-first-out) data structure. Items are inserted ("enqueued") onto a queue at the back or tail, and deleted ("dequeued", similar to popping a stack) from the front or head.

Queues are used instead of stacks when we want FIFO behavior instead of LIFO behavior. For instance, a system that processes database transactions should process them in order. If the transactions are placed on a queue, the database can take the next transaction to be done from the head of the queue while other transactions wait in the middle of the queue, and new transactions are inserted at the end.

Here are some operations a queue ADT should support. Note the similarity to a stack:

create(Q) - create an empty queue Q.
enqueue(Q, k) - insert an item k at the end of the queue Q.
dequeue(Q) - delete an item from the front of the queue, returning its value.
head(Q) - return the value of the head of the queue.
empty(Q) - return true if and only if the queue is empty.

Like stacks, queues can be implemented either in arrays or with linked lists. Here is an array implementation of some queue functions:

/* size of queue */

#define MAXQ	100

/* queue ADT type */

typedef struct _queue {
	int	head, tail;
	float	v[MAXQ];
} queue;

/* make a queue; head = tail = 0 */

void create_queue (queue *Q) {
	Q->head = 0;
	Q->tail = 0;
}

/* put k onto queue Q */
void enqueue (queue *Q, float k) {
	Q->v[Q->tail] = k;
	Q->tail++;
	Q->tail %= MAXQ;
	if (Q->tail == Q->head) {
		fprintf (stderr, "queue full!\n");
		exit (1);
	}
}

/* remove from queue and return */

float dequeue (queue *Q) {
	float	r;

	if (Q->head == Q->tail) {
		fprintf (stderr, "queue empty!\n");
		exit (1);
	}
	r = Q->v[Q->head];
	Q->head++;
	Q->head %= MAXQ;
	return r;
}

/* return true iff queue is empty */

int emptyq (queue Q) {
	return Q.head == Q.tail;
}