数据结构（三）之队列ADT

像栈一样，队列也是表。然而，使用队列时插入在一段进行而删除则在另一端进行。队列的基本操作是Enqueue（入队），它是在表的末端（叫做队尾（rear））插入一个元素，还有Dequeue（出队），它是删除（或返回）在表的开头（叫做队头（front））的元素。通过数组和链表都可以实现队列，其中数组更普遍一点。

在考虑数组实现时，由于数组的大小是有限的，为了操作更多的元素，我们可以用循环数组实现，即只要Front或Rear到达数组的尾端，它又绕回到开头。在考虑队列的循环实现，有两件事情要警惕，一是检测队列是否为空很重要的，因为空时一次Dequeue操作返回一个不确定的值。二是某些程序设计人员使用不同的方法来表示队列和队尾。目前比较普遍的有三种方法：

其一是使用一个计数器记录队列中元素的总数（实际上是队列长度）。

其二是少用一个元素的空间，约定入队前，测试尾指针在循环意义下加1后是否等于头指针，若相等则认为队满（注意：rear所指的单元始终为空）；

其三是另设一个布尔变量以匹别队列的空和满；

本文主要介绍前面两种方法。第三种比较简单，读者可自行实现。

1. 循环数组实现。添加一个计数器记录队列中元素的总数

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct QueueRecord *Queue;

Queue createQueue(int MaxElements);
void disposeQueue(Queue Q);
void enqueue(ElementType X, Queue Q);
ElementType dequeue(Queue Q);

struct QueueRecord
{
	int Capacity;
	int Size;
	int Front;
	int Rear;
	ElementType *Array;
};


Queue createQueue(int MaxElements)
{
	Queue Q;

	Q = (Queue)malloc(sizeof(QueueRecord));
	if(Q == NULL)
		return NULL;

	Q->Array = (ElementType *)malloc(MaxElements * sizeof(ElementType));
	if(Q->Array == NULL)
		return NULL;

	Q->Capacity = MaxElements;
	Q->Size = 0;
	Q->Front = 0;
	Q->Rear = -1;

	return Q;
}

void disposeQueue(Queue Q)
{
	if(Q != NULL)
	{
		free(Q->Array);
		free(Q);
	}
	return;
}

void enqueue(ElementType X, Queue Q)
{
	if(Q->Size >= Q->Capacity)	    //队列已满
		return;

	if(++Q->Rear == Q->Capacity)	//假溢出
		Q->Rear = 0;
	Q->Size++;
	Q->Array[Q->Rear] = X;

	return;
}

ElementType dequeue(Queue Q)
{
	if(Q->Size == 0)
		return 0;

	Q->Size--;
	int tmp = Q->Front; 
	Q->Front = (Q->Front + 1) % Q->Capacity;

	return Q->Array[tmp];
}

//循环打印
void printQueue(Queue Q)
{
	int Rear;

	if(Q == NULL || Q->Size == 0)
		return;

	Rear = Q->Rear;
	if(Q->Front > Rear)
		Rear += Q->Capacity;
	for(int i = Q->Front;i <= Rear; ++i)
	{
		if(i >= Q->Capacity)
			printf("%d", Q->Array[i - Q->Capacity]);
		else
			printf("%d", Q->Array[i]);
	}
	printf("\n");
	return;
}


int main()
{
	Queue Q;

	Q = createQueue(10);
	if(Q == NULL)
		return 0;

	enqueue(9, Q);
    printf("%d\n", dequeue(Q));

	for(int i=0; i<10; ++i)
	{
		enqueue(i, Q);
	}
	printQueue(Q);

    printf("%d\n", dequeue(Q));
	printQueue(Q);

	enqueue(9, Q);
	enqueue(9, Q);
	printQueue(Q);

	disposeQueue(Q);

	system("pause");
	return 0;
}

2.  循环数组实现。少用一个元素的空间，约定入队前，测试尾指针在循环意义下加1后是否等于头指针，若相等则认为队满（注意：rear所指的单元始终为空）

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct QueueRecord *Queue;

Queue createQueue(int MaxElements);
void disposeQueue(Queue Q);
void enqueue(ElementType X, Queue Q);
ElementType dequeue(Queue Q);

struct QueueRecord
{
	int Capacity;
	int Front;
	int Rear;
	ElementType *Array;
};


Queue createQueue(int MaxElements)
{
	Queue Q;

	Q = (Queue)malloc(sizeof(QueueRecord));
	if(Q == NULL)
		return NULL;

	Q->Array = (ElementType *)malloc(MaxElements * sizeof(ElementType));
	if(Q->Array == NULL)
		return NULL;

	Q->Capacity = MaxElements;
	Q->Front = 0;
	Q->Rear = 0;

	return Q;
}

void disposeQueue(Queue Q)
{
	if(Q != NULL)
	{
		free(Q->Array);
		free(Q);
	}
	return;
}

void enqueue(ElementType X, Queue Q)
{
	int rear;

	rear = (Q->Rear+1) % Q->Capacity;
	if(rear == Q->Front)
		return;
	Q->Array[Q->Rear] = X;
	Q->Rear = rear;

	return;
}

ElementType dequeue(Queue Q)
{
	if(Q->Front == Q->Rear)
		return 0;
	
	int tmp = Q->Front; 
	Q->Front = (Q->Front + 1) % Q->Capacity;
	return Q->Array[tmp];
}

void printQueue(Queue Q)
{
	int Rear;

	if(Q == NULL || Q->Front == Q->Rear)
		return;

	Rear = Q->Rear;
	if(Q->Front > Rear)
		Rear += Q->Capacity;
	for(int i = Q->Front;i < Rear; ++i)
	{
		if(i >= Q->Capacity)
			printf("%d", Q->Array[i - Q->Capacity]);
		else
			printf("%d", Q->Array[i]);
	}
	printf("\n");
	return;
}


int main()
{
	Queue Q;

	Q = createQueue(10);
	if(Q == NULL)
		return 0;

	enqueue(9, Q);
    printf("%d\n", dequeue(Q));

	for(int i=0; i<10; ++i)
	{
		enqueue(i, Q);
	}
	printQueue(Q);

    printf("%d\n", dequeue(Q));
	printQueue(Q);

	enqueue(9, Q);
	enqueue(9, Q);
	printQueue(Q);

	disposeQueue(Q);

	system("pause");
	return 0;
}

3. 单链表实现。

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct Node *PtrToNode;
typedef struct QueueRecord *Queue;

Queue createQueue();
void disposeQueue(Queue Q);
void enqueue(ElementType X, Queue Q);
ElementType dequeue(Queue Q);

struct QueueRecord
{
	PtrToNode Front;
	PtrToNode Rear;
};

struct Node
{
	ElementType Element;
	PtrToNode Next;
};


Queue createQueue()
{
	PtrToNode head;

	head = (PtrToNode)malloc(sizeof(struct Node));
	if(head == NULL)
		return NULL;

	head->Next = NULL;

	Queue q;
	q = (Queue)malloc(sizeof(struct QueueRecord));
	if(q == NULL)
		return NULL;

	q->Front = head;
	q->Rear = head;

	return q;
}

void disposeQueue(Queue Q)
{
	PtrToNode p;
	PtrToNode tmp;

	if(Q == NULL || Q->Front == NULL)
		return;

	p = Q->Front->Next;
	free(Q->Front);
	free(Q);
	while(p != NULL)
	{
		tmp = p;
		p = p->Next;
		free(tmp);
	}
	return;
}

void enqueue(ElementType X, Queue Q)
{
	PtrToNode tmp;

	tmp = (PtrToNode)malloc(sizeof(struct Node));
	if(tmp == NULL)
		return;

	tmp->Element = X;
	tmp->Next = NULL;

	Q->Rear->Next = tmp;
	Q->Rear = tmp;
	return;
}

ElementType dequeue(Queue Q)
{
	PtrToNode tmp;

	if(Q == NULL || Q->Front == NULL || Q->Front->Next == NULL)
		return 0;
	tmp = Q->Front->Next;
	Q->Front->Next = tmp->Next;
	if(tmp == Q->Rear)
		Q->Rear = Q->Front;
	ElementType x = tmp->Element;
	free(tmp);

	return x;
}

void printQueue(Queue Q)
{
	PtrToNode p;

	if(Q == NULL || Q->Front == NULL || Q->Front->Next == NULL)
		return;

	p = Q->Front->Next;
	while(p != NULL)
	{
		printf("%d", p->Element);
		p = p->Next;
	}
	printf("\n");

	return;
}

int main()
{
	Queue Q;

	Q = createQueue();
	if(Q == NULL)
		return 0;

	enqueue(1, Q);
	printf("%d\n", dequeue(Q));
	printf("%d\n", dequeue(Q));

	for(int i =0; i < 10; ++i)
		enqueue(i, Q);
	printQueue(Q);

	printf("%d\n", dequeue(Q));
	printQueue(Q);

	enqueue(9, Q);
	printQueue(Q);

	disposeQueue(Q);

	system("pause");

	return 0;
}

队列主要的应用在于排队论。