顺序队

typedef struct {
	ElemType data[MAXSIZE];
	int front, rear;
}SqQueue;

void InitQueue(SqQueue*& q)
{
	q = (SqQueue*)malloc(sizeof(SqQueue));
	q->front = -1;
	q->rear = -1;
}

void DestroyQueue(SqQueue*& q)
{
	free(q);
}

bool QueueEmpty(SqQueue* q)
{
	return (q->front == q->rear);
}

bool enQueue(SqQueue*& q, ElemType e)
{
	if (q->rear == MAXSIZE - 1)
		return false;

	q->rear++;
	q->data[q->rear] = e;
	return true;
}

bool  deQueue(SqQueue*& q, ElemType& e)
{
	if (q->front == q->rear)
		return false;

	q->front++;
	e = q->data[q->front];
	return true;
}

typedef struct {
	ElemType data[MAXSIZE];
	int front, rear;
}SqQueue1;

void InitQueue1(SqQueue1*& q)
{
	q = (SqQueue1*)malloc(sizeof(SqQueue1));
	q->front = q->rear = 0;
}

void DestroyQueue1(SqQueue1*& q)
{
	free(q);
}

bool QueueEmpty(SqQueue1* q)
{
	return (q->front == q->rear);
}

bool enQueue1(SqQueue1*& q, ElemType e)
{
	if ((q->rear + 1) % MAXSIZE == q->front)
		return false;
	
	q->rear = (q->rear + 1) % MAXSIZE;
	q->data[q->rear] = e;
	return true;
}

bool delQueue(SqQueue1*& q, ElemType& e)
{
	if (q->rear == q->front)
		return false;

	q->front = (q->front + 1) % MAXSIZE;
	e = q->data[q->front];
	return true;
}

typedef struct {
	ElemType data[MAXSIZE];
	int front;
	int count;
}SqQueue2;

void InitQueue2(SqQueue2*& qu)
{
	qu = (SqQueue2*)malloc(sizeof(SqQueue2));
	qu->front = 0;
	qu->count = 0;
}

bool QueueEmpty2(SqQueue2* qu)
{
	return (qu->count == 0);
}

bool enQueue2(SqQueue2*& qu, ElemType e)
{
	int rear;
	if (qu->count == MAXSIZE)
		return false;
	
	rear = (qu->front + qu->count) % MAXSIZE;
	rear = (rear + 1) % MAXSIZE;
	qu->data[rear] = e;
	qu->count--;
	return true;
}

bool delQueue(SqQueue2*& qu, ElemType& e)
{
	if (qu->count == 0)
		return false;

	qu->front = (qu->front + 1) % MAXSIZE;
	e = qu->data[qu->front];
	qu->count--;
	return true;
}