数据结构学习——队列

每当夜幕降临，都会在想今天学到了什么，是继续迷茫的像机器人似的忙于项目，还是去做一点自己真正喜欢的事？我想更重要的还是先认清自己，做自己认为正确的事，正如现在所做的一样，即使每天都是毫无意义的工作，还是要坚持输出，坚持学习！
相信所有的质变都是量变的积累，2021加油！

队列

1. 什么是队列？

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
队列是一种先进先出的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为对头。
设计队列的目的时为了模拟离散事件发生的先后顺序，例如CPU中的指令队列，操作系统中的作业调度等。

• 队列的顺序存储结构
  可以用数组来表示队列，初始化队头指针和队尾指针都指向数组下标为0的空间，插入元素时，队尾指针后移，删除元素时，队头指针所指空间数据清除，队头指针后移一位。
  

然而，顺序队列存在“假溢出”的问题。如下图所示，队列中仍然有多余的空间，但队尾却不能插入元素了，否则会产生数组越界的错误，正如《大话数据结构》里所言，上了公交车，发现后排座位坐满了，而前排还有两个座位，难道要下车等下一辆公交车吗？当然不是，于是研究者们又提出了“循环队列”来解决这个问题。

2. 循环队列

顾名思义，循环队列就是头尾相接的队列，队尾插满了就将队尾指针挪到最开始的空间去，从头开始。

那么又出现新的问题了，在循环队列中如何判断队空和队满？

在顺序存储中队空是 front =rear ，队满则是 rear = QueueSize，而在循环队列中则都是 front==rear了，如何解决这个问题呢？

研究者们又提出，循环队列保留一个元素空间 ，即数组中还有一个空闲单元。当出现如下两种情况时则认为队列满了。


故循环队列的队空与队满可表示为：

• 队空：front == rear
• 队满： (rear+1)%QueueSize == front

计算队列长度的公式为：

(rear - front + QueueSize) % QueueSize

3.队列的链式存储结构

队列的链式存储结构，其实就是线性表的单链表，只不过它是只能尾进头出而已，简称为链队列。为了操作上方便，一般将队头指针指向链队列的头结点，而队尾指针指向终端结点。

4.循环队列实现

1.链队结构

同单链表类似，结点有数据域和指向下一个结点的指针域，队列链表有两个指针，队头和队尾指针。

//链队结构
typedef int QElemType;
typedef struct QNode    //结点结构
{
	QElemType data;
	struct QNode *next;
}QNode,*QueuePtr;

typedef struct      //队列链表结构
{
	QueuePtr front,rear;   //队头、队尾指针
}LinkQueue;

2. 入队

在队尾插入元素时，只需新建一个结点 s，然后将队尾结点的next指向插入结点 s，将队尾指针指向 插入结点 s，具体如下图所示。

int Queue::EnQueue(LinkQueue *Q,QElemType e)
{
	QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
	if(!s)
	{
		printf("内存分配失败！\n");
		return 0;
	}
	s->data = e;
	s->next = NULL;
	
	Q->rear->next = s;   //将队尾结点的next指向插入结点 s
	Q->rear = s;     //将队尾指针指向 插入结点 s
	return 1;
}

3. 出队

出队则是先判断队列是否为空，如果不为空，则定义一个结点p指向队头，将队头元素放到e里输出，如果此时队头就是队尾，则还需要将尾指针rear指向头结点。

值得注意的是：队头指针的next要指向队头的next，而不是队头指针指向队头的next ！！

int Queue::DeQueue(LinkQueue *Q,QElemType &e)
{
	if(Q->front == Q->rear)
	{
		printf("队空！\n");
		return 0;
	}
	QueuePtr p = Q->front->next;   //令 p 为队头元素
	e = p->data;
	Q->front->next = p->next;    //注意是 Q->front->next!!!
	//若队头是队尾，则删除后将rear指向头结点
	if(Q->rear == p)
		Q->rear = Q->front;
	free(p);
	return 1;
}

3. 完整C++代码如下

//Queue.h
#ifndef QUEUE_H
#define QUEUE_H

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

// 用 c++ 实现 链队

//链队结构
typedef int QElemType;

typedef struct QNode    //结点结构
{
	QElemType data;
	struct QNode *next;
}QNode,*QueuePtr;

typedef struct      //队列链表结构
{
	QueuePtr front,rear;   //队头、队尾指针
}LinkQueue;

// 定义链表类
class Queue
{
	public:
		LinkQueue* Q;
		LinkQueue* QueueInit();  //链表初始化
		int PrintQueue(LinkQueue *Q);   //打印队列
		int EnQueue(LinkQueue *Q,QElemType e);   //入队
		int DeQueue(LinkQueue *Q,QElemType &e);  //出队
		
		Queue();
		~Queue();
};

Queue::Queue()
{
	this->Q = QueueInit();
	//Pi 50-60
	EnQueue(this->Q,69);
	EnQueue(this->Q,39);
	EnQueue(this->Q,93);
	EnQueue(this->Q,75);
	EnQueue(this->Q,10);
	
	EnQueue(this->Q,58);
	EnQueue(this->Q,20);
	EnQueue(this->Q,97);
	EnQueue(this->Q,49);
	EnQueue(this->Q,44);
	PrintQueue(this->Q);
}

Queue::~Queue() { }


LinkQueue* Queue::QueueInit()
{
	QueuePtr node = (QueuePtr)malloc(sizeof(QNode));  //定义一个头结点
	node->next = NULL;
	
	LinkQueue* Queue = new(LinkQueue);
	Queue->front = node;
	Queue->rear = node;
	return Queue;
}


int Queue::PrintQueue(LinkQueue *Q)
{
	QueuePtr cur = Q->front->next;
	int i=1;
	if(Q->front == Q->rear)
	{
		printf("队空！\n");
		return 0;
	}
	
	while(cur != Q->rear)
	{
		printf("第%d个元素为 %d \n",i,cur->data);
		cur = cur->next;
		i++;
	}
	printf("第%d个元素为 %d \n",i,cur->data);
	return 1;
}

int Queue::EnQueue(LinkQueue *Q,QElemType e)
{
	QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
	if(!s)
	{
		printf("内存分配失败！\n");
		return 0;
	}
	s->data = e;
	s->next = NULL;
	
	Q->rear->next = s;   //将队尾结点的next指向插入结点 s
	Q->rear = s;     //将队尾指针指向 插入结点 s
	return 1;
}

int Queue::DeQueue(LinkQueue *Q,QElemType &e)
{
	if(Q->front == Q->rear)
	{
		printf("队空！\n");
		return 0;
	}
	QueuePtr p = Q->front->next;   //令 p 为队头元素
	e = p->data;
	Q->front->next = p->next;    //注意是 Q->front->next!!!
	
	//若队头是队尾，则删除后将rear指向头结点
	if(Q->rear == p)
		Q->rear = Q->front;
	
	free(p);
	return 1;

}

#endif 

//Queue_node.cpp
#include "Queue.h"

using namespace std;

int main(int argc,char** argv)
{
	int e = 0;
	Queue LinkQueue;
	LinkQueue.DeQueue(LinkQueue.Q,e);
	printf("===========  出队元素为  %d ===============\n",e);
	LinkQueue.PrintQueue(LinkQueue.Q);
	return 0;
}

5. 运行结果