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