3.2 队列

        定义: 队列是一种插入元素只能在一端进行, 删除元素只能在另一端进行的线性表. 所谓队列是线性表, 是指队列的逻辑结构属于线性表, 只不过在操作上加了一些约束. 队列可以插入元素的一端叫做队尾(Rear), 可以删除元素的一端叫做队头(Front). 队列是一种先进先出的结构. First In, First Out (FIFO). 

图1. 元素入队和出队

1. 顺序队列(循环队列)

 图2. 元素入队

 图3. 元素出队

        如图, front指针指向队列首个元素的前一个位置, rear指向队列的最后一个元素. front和rear的初始值均为0. 关于入队和出队操作以及判断队空, 可以这样规定: 

        入队: 先移动队尾指针, 再入队元素; 即rear++; queue[ rear ] = x; 

        出队: 先移动队头指针, 再出队元素; 即front++; x = queue[ front ]; 元素出队后它的值还是残留在数组中的, 但已不属于队列. 

        队空: rear == front; 

        需要注意的是, 这只是一种规定, 在不同的规定下入队和出队及判断队空可能会有所不同. 

 图4. 假溢出

        如图, rear再向后移动会造成数组越界, 但是数组内确实有空位置存在, 这种情况称为假溢出. 

 图5. 假溢出解决方法

        注意, 上图只是一种演示方法, 实际上在内存中数组是不会被"掰弯"的. 

        如图, 定义队列queue[MAX_SIZE], front和rear初始值均为0.

        入队时, 仍是先移动指针rear, 与之前不同的是, 当rear越界时, 需要让rear折返回数组的起始位置, 即rear = ( rear + 1 ) % MAX_SIZE; 然后入队元素, 即queue[ rear ] = x; 

        出队时, 仍时先移动指针front, 与之前不同的是, 当front越界时, 需要让front折返回数组的起始位置, 即front = ( front + 1 ) % MAX_SIZE; 然后出队元素, 即x = queue[ front ]; 

        队空: front == rear 为真; 

        队满: front == ( rear + 1 ) % MAX_SIZE为真; 

#include <iostream>

const int MAX_SIZE = 10;

/// <summary>
/// 队列结构体定义
/// </summary>
typedef struct {
	int data[MAX_SIZE];
	int front, rear;
}SqQueue;

/// <summary>
/// 初始化队列
/// </summary>
/// <param name="Q"></param>
void InitQueue(SqQueue& Q) {
	Q.front = 0;
	Q.rear = 0;
}

/// <summary>
/// 元素入队
/// </summary>
/// <param name="Q"></param>
/// <param name="x">入队元素</param>
void EnQueue(SqQueue& Q, int x) {
	Q.rear = (Q.rear + 1) % MAX_SIZE;
	Q.data[Q.rear] = x;
}

/// <summary>
/// 元素出队
/// </summary>
/// <param name="Q"></param>
/// <param name="x"></param>
void DeQueue(SqQueue& Q, int &x) {
	Q.front = (Q.front + 1) % MAX_SIZE;
	x = Q.data[Q.front];
}

/// <summary>
/// 判断队空, 若队空返回true, 否则返回false
/// </summary>
/// <param name="Q"></param>
/// <returns></returns>
bool QueueEmpty(SqQueue Q) {
	if (Q.front == Q.rear) {
		return true;
	}
	return false;
}

/// <summary>
/// 判断队满, 若队满返回true, 否则返回false
/// </summary>
/// <param name="Q"></param>
/// <returns></returns>
bool QueueFull(SqQueue Q) {
	if (Q.front == (Q.rear + 1) % MAX_SIZE) {
		return true;
	}
	return false;
}

int main()
{
	SqQueue Q;
	InitQueue(Q);
	int i = 0;
	while (!QueueFull(Q))
	{
		printf("入栈元素: %d\n", i);
		EnQueue(Q, i);
		i++;
	}
	printf("---------------------------\n");
	while (!QueueEmpty(Q))
	{
		int x;
		DeQueue(Q, x);
		printf("出栈元素: %d\n", x);
	}
}

代码1: 顺序队列的基本操作

        运行结果如下: 

 图6. 运行结果

        可以看出容量为10的数组在队满时只容纳了9个元素. 有一个位置没有容纳元素. 

2. 链式队列

 图7. 链式队列

        如图, front指向链式队列的头结点, rear指向链式队列的尾结点. 

        入队: p指向入队结点, 注意是从队尾入队. p->next = rear->next; rear->next = p; rear = p; 

        出队: p指向出队结点, 注意是从队头出队. p = front->next; front->next = p->next; x = p->data; free(p); 

        队空: front->next == NULL为真; 

        队满: 假设内存足够大, 不考虑内存满的情况. 

        很多考题里将front和rear包在一个结构体变量里. 

 图8. 将front和rear包在一个结构体变量里

        图中的队列没有头结点, front指向队列首个元素, 当front == NULL时, 队列为空. 为了统一操作, 我们在代码实现时设计成带头结点的单链表. 则front指向头结点, front==rear时, 队列为空. 

#include <iostream>

/// <summary>
/// 链式队列结点结构体
/// </summary>
typedef struct LNode {
	int data;
	struct LNode* next;
}LNode;

/// <summary>
/// 链式队列
/// </summary>
typedef struct {
	struct LNode* front;
	struct LNode* rear;
}LinkQueue;

/// <summary>
/// 初始化队列
/// </summary>
/// <param name="Q"></param>
void InitQueue(LinkQueue& Q) {
	LNode* H = (LNode*)malloc(sizeof(LNode));
	H->data = NULL;
	H->next = NULL;

	Q.front = H;
	Q.rear = H;
}

/// <summary>
/// 入队
/// </summary>
/// <param name="Q"></param>
/// <param name="x">入队元素</param>
void EnQueue(LinkQueue& Q, int x) {
	LNode* p = (LNode*)malloc(sizeof(LNode));
	p->data = x;
	p->next = NULL;

	//下面这个if()语句是不必要的, 因为Q.rear->next = p;这句代码会设置Q.front.next为p, 当然写出来也不会错
	//if (Q.front == Q.rear) {	//若入队前队列为空, 则先设置Q.front.next为首个入队元素
	//	Q.front->next = p;
	//}

	p->next = Q.rear->next;
	Q.rear->next = p;		//若入队前队列为空, 这一句会设置Q.front.next为p, 
							//因为队列为空时, Q.front == Q.rear == H
	Q.rear = p;				//这里改变了Q.rear的指向的元素, 故再次入队时, 
							//Q.rear->next = p;不会再改变Q.front的next的值, 
							//也即Q.front.next始终指向了队列首个元素

	//free(p);		注意这里不能释放p所指结点的内存空间
}

/// <summary>
/// 出队
/// </summary>
/// <param name="Q"></param>
/// <param name="x">出队元素</param>
void DeQueue(LinkQueue& Q, int& x) {
	LNode* p = Q.front->next;

	x = p->data;

	Q.front->next = p->next;

	if (Q.rear == p) {
		Q.rear = Q.front;		//若原队列只有一个结点, 删除后变空
	}

	free(p);
}

/// <summary>
/// 判断队空, 队空返回true, 队不空返回false
/// </summary>
/// <param name="Q"></param>
/// <returns></returns>
bool QueueEmpty(LinkQueue Q) {
	if (Q.front == Q.rear) {
		return true;
	}
	return false;
}

int main()
{
	LinkQueue Q;
	InitQueue(Q);

	int i = 1;
	while (i < 10) {
		printf("入队元素: %d\n", i);
		EnQueue(Q, i);
		i++;
	}
	printf("-----------------------------\n");

	while (!QueueEmpty(Q))
	{
		int x;
		DeQueue(Q, x);
		printf("出队元素: %d\n", x);
	}
}

代码2: 链式队列的基本操作