队列

队列

定义

队列，（queue），是先进先出（FIFO, First-In-First-Out）的线性表。在具体应用中通常用链表或者数组来实现。队列只允许在后端（称为rear）进行插入操作，在前端（称为front）进行删除操作。
队列的操作方式和堆栈类似，唯一的区别在于队列只允许新数据在后端进行添加。
顺序队列中的溢出现象
下溢：队列为空时，做出队操作产生的溢出现象
真上溢：当队列满时，做入队操作产生的空间溢出现象
假上溢：由于入队和出队操作中，队头指针只增加不减少，致使被删除的元素空间永远无法重新利用，从而导致入队操作时产生假上溢现象

队列的操作有 init isEmpty isFull enqueue dequeue clear getLenth 

const int N=1000;
typedef struct {
	int data[N];
	int rear;// 指向队尾元素
	int front;// 指向队头元素的前一个位置(队列外)
	int length;
}queue;
queue* init()

{
	queue *q=(queue*)malloc(sizeof(queue));
	q->rear=-1;
	q->front=-1;	
	q->length=0;
}
bool isEmpty(queue* q)
{
	return q->length==0;
}
bool isFull(queue* q)
{
	return q->length==N;
}
void enqueue(int n,queue* q)
{
	if(isFull(q))
	{
		cout<<"queue full"<<endl;
	}else{
		q->length++;
		q->rear=(q->rear+1)%N;
		q->data[q->rear]=n;
	}

}
int dequeue(queue* q)
{
	if(isEmpty(q))
	{
		cout<<"queue empty"<<endl;
	}else{
		q->length--;
		q->front=(q->front+1)%N;
		return q->data[q->front];			
	}
	
}
void clear(queue* q)
{
	q->length=0;
	q->rear=-1;
	q->front=-1;
}
int getLength(queue* q)
{
	return q->length;
}
/*************************************/
链表队列
typedef struct{
	int data;
	node* next;
}node;
typedef struct{
	node* front;// 指向头
	node* rear;// 指向尾
}queue;
queue* init()
{
	queue* q=(queue*)malloc(sizeof(queue));
	q->front=null;
	q->rear=null;	
}
bool isEmpty(queue* q)
{
	if(q->front==null&&q->rear==null)
		return true;
	return false;
}
void enqueue(int n,queue* q)
{
	node* p=(node*)malloc(sizeof(node));
	p->data=n;
	p->next=null;
	if(isEmpty(q))
	{
		q->rear=p;
		q->front=p;
	}
	else
	{
		q->rear->next=p;
		q->rear=p;
	}
}
int dequeue(queue* q)
{
	if(isEmpty(q))
	{
		cout<<"empty"<<endl;
	}
	else
	{
		node* p=q->front;
		int t=p->data;
		q->front=p->next;
		if(q->rear==p)// 如果只有一个节点,尾部也指向头部,则尾部要置空
			q->rear=null;
		free(p);
		return t;
	}
		
}
void clear(queue* q)
{
	while(q->front)
		dequeue(q);
}
int getLength(queue* q)
{
	int i=0;
	while(q->front){
		i++;
		q->front=q->front->next;
	}
	return i;
}

循环队列

链队列

问题

两个栈构造一个队列

两个队列构造一个栈

队列中取最大值问题

应用

FIFO型离散事件的模拟