ADT队列/FIFO表

队列是一种特殊的表，只在表首进行删除，只在表尾进行插入，按照先进先出原则操作(First In First Out)，又称为FIFO表；

队列的指针实现代码：

#include<cstdio>
#include<cstdlib>
#include<algorithm>
typedef struct node* link;
typedef struct node
{
	int element;
	link next;
}Node;
typedef struct aque* Queue;
typedef struct aque
{
	link front;                                //队首节点指针
	link last;                                 //队尾节点指针
}Aque;

Queue QueueInit(Queue Q)
{
	Q->front=Q->last=0;
	return Q;
}
int QueueEmpty(Queue Q)
{
	return Q->front==0;
}
int QueueFull(Queue Q)
{
	//这里个人认为通过指针实现的队列（在现阶段我的使用中）可以不需要判断队列空间是否已满；
}
int QueueFirst(Queue Q)
{
	return Q->front->element;
}
int QueueLast(Queue Q)
{
	return Q->last->element;
}
void EnterQueue(int x,Queue Q)
{
	link p;
	p=new Node;                                 //创建一个新的节点
	p->element=x;p->next=0;
	if(Q->front)                                //如果队列非空
	{
		Q->last->next=p;
	}
	else Q->front=p;                            //空队列
	Q->last=p;
}
int DeleteQueue(Queue Q)
{
	link p;
	int x=Q->front->element;
	p=Q->front;
	Q->front=Q->front->next;
	free(p);
	return x;
}
int main()
{
	int i,j,k;
	Queue Q=new Aque;
	QueueInit(Q);
	EnterQueue(5,Q);
	EnterQueue(2,Q);
	printf("%d",QueueFirst(Q));
	DeleteQueue(Q);
	EnterQueue(0,Q);
	while(QueueEmpty(Q)!=1)
	{
		printf("%d",QueueFirst(Q));
		DeleteQueue(Q);
	}
	return 0;
}

用循环数组实现队列代码：

循环数组的形状如下：

#include<cstdio>
#include<cstdlib>
#include<malloc.h>
typedef struct aque* Queue;
typedef struct aque
{
	int maxsize;
	int front;                                                         //队头游标
	int last;                                                          //队尾游标
	int* queue;
}Aque;
Queue QueueInit(int size,Queue Q)
{
	Q->queue=(int*)malloc(size*sizeof(int));
	Q->maxsize=size;
	Q->front=Q->last=0;
	return Q;
}
int QueueEmpty(Queue Q)
{
	return Q->front==Q->last;                                           //如果此时队列是空的，那么front和last游标在同一个位置 ；
}
int QueueFull(Queue Q)
{
	return (((Q->last+1)%Q->maxsize==Q->front)?1:0);                   //如果此时队列是满的那么front和last是游标相邻的；
}
int QueueFirst(Queue Q)
{
	return Q->queue[(Q->front+1)%Q->maxsize];
}
int QueueLast(Queue Q)
{
	return Q->queue[Q->last];
}
void EnterQueue(int x,Queue Q)
{
	Q->last=(Q->last+1)%Q->maxsize;
	Q->queue[Q->last]=x;
}
int DeleteQueue(Queue Q)
{
	Q->front=(Q->front+1)%Q->maxsize;
	return Q->queue[Q->front];
}
int main()
{
	int i,j,n;
	scanf("%d",&n);
	Queue Q=new Aque;
	QueueInit(n,Q);
	EnterQueue(5,Q);
	EnterQueue(2,Q);
	printf("%d",DeleteQueue(Q));
	EnterQueue(0,Q);
	while(QueueEmpty(Q)!=1)
	{
		printf("%d",QueueFirst(Q));
		DeleteQueue(Q);
	}
	return 0;
}

思想：通过游标指向的变化，来判断队列是否已经满或者空；

栈在STL中有直接的函数可以使用，队列也是一样的，需要包括的文件时queue；

STL中队列使用代码：

#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<queue>
using namespace std;
queue<int> q;
int main()
{
	int i,j,n;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
	{
		int tmp;
		scanf("%d",&tmp);
		q.push(tmp);
	}
	printf("%d",q.front());
	q.pop();
	while(q.empty()!=1)
	{
		printf("%d",q.front());
		q.pop();
	}
	return 0;
}

第四次作业：

1、（计算一个数列中长度不超过k的数字之和的最大值）：这种数列中某个长度对数字的操作，一般可以通过单调队列写；单调队列（最大值队列）思想是：只需要维护一个递减的数组，每次要输入到维护中的数如果比数组中最后的数小，直接加入，否则，数组中的数一定不是结果，则将其替换成要输入的这个数；具体理解可以看之前的一篇博客，里面也有单调队列相关的例题及代码；

这题先对数列求其前缀和（每个数其前面所有数的和），通过一个que数组存储sum的下标，维护这个que数组使之存储的下标其sum数组值中是一个递增的序列（因为通过每次存储比之更大的，就已经对所有的更大的sum都做了一个if判断，储存了其中的max）；

代码：

#include<stdio.h>
#include<iostream>
using namespace std;

const int Len = 100000 + 5;
int a[Len], que[Len], top, tail;
int main() {
	int n, k, ans = -100000000, l, r, i;
	cin >> n >> k;
	que[top++] = 0; l = 1; r = 1;
	for (i = 1; i <= n; i++)
	{
		cin >> a[i];
		a[i] += a[i - 1];
		while (top>tail&&i - que[tail]>k)tail++;
		if (ans<a[i] - a[que[tail]])
		{
			ans = a[i] - a[que[tail]];
			l = que[tail] + 1; r = i;
		}
		while (top>tail&&a[que[top - 1]]>a[i])	{top--;}
		que[top++] = i;
	}
	printf("%d %d %d\n", ans, l, r);
}

第二题：（队列的基础运算用法）：直接用一个队列将数字存储，然后按照题面意思对队列做删除等操作，就可以解出来；