队列的基本操作

队列： 先进先出结构

限定性数据结构的双端队列：
输出受限的双端队列： 一个端点允许插入和删除，另一个端点只允许插入的双端队列
输入受限的双端队列： 一个端点允许插入和删除，另一个端点只允许删除的双端队列

head=rear 队空
(read+1)%size=head 队满

队列实现
头文件：

typedef int ElemType;
#define MAXQSIZE 10

typedef struct Queue
{
 ElemType *base;
 int      head;
 int      rear;
}SqQueue;

//初始化
void InitQueue(SqQueue *que);
//判空
int EmptyQueue(SqQueue *que);
//判满
int FullQueue(SqQueue *que);
//入队
int PushQueue(SqQueue *que,ElemType val);
//获取头结点
int GetHead(SqQueue *que, ElemType *val);
//出队
int PopQueue(SqQueue *que,ElemType *val);
//清除数据
void ClearQueue(SqQueue *que);
//销毁队列
void DistoryQueue(SqQueue *que);

功能实现：

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include"queue.h"
//判空
static void DeterPointNull(SqQueue *que)
{
 assert(que!=NULL);
 if(que==NULL)
 {
  exit(0);
 }
}
//初始化
void InitQueue(SqQueue *que)
{
 DeterPointNull(que);
 
 que->base=(ElemType *)malloc(sizeof(ElemType)* MAXQSIZE);
 assert(que->base!=NULL);
 
 que->head=que->rear=0;
}
//判空
int EmptyQueue(SqQueue *que)
{
 DeterPointNull(que);
 
 if(que->head == que->rear)
 {
  return 1;
 }
 return 0;
}
//判满
int FullQueue(SqQueue *que)
{
 DeterPointNull(que);
 
 if((que->rear+1)%MAXQSIZE==que->head)
 {
  return 1;
 }
 return 0;
}
//入队
int PushQueue(SqQueue *que,ElemType val)
{
 DeterPointNull(que);
 
 if(FullQueue(que))
 {
  return 0;
 }
 que->base[que->rear]=val;
 que->rear=(que->rear+1)%MAXQSIZE;
 
 return 1;
}
//获取头结点
int GetHead(SqQueue *que, ElemType *val)
{
 DeterPointNull(que);
 
 if(EmptyQueue(que))
 {
  return 0;
 }
 *val=que->base[que->head];
 
 return 1;
}
//出队
int PopQueue(SqQueue *que,ElemType *val)
{
 DeterPointNull(que);
 
 if(!GetHead(que,val))
 {
  return 0;
 }
 que->head=(que->head+1)%MAXQSIZE;
 
 return 1;
}
//清除数据
void ClearQueue(SqQueue *que)
{
 DeterPointNull(que);
 
 que->head=que->rear=0;
}
//销毁队列
void DistoryQueue(SqQueue *que)
{
 DeterPointNull(que);
 
 free(que->base);
 que->base=NULL;
 que->head=que->rear=0;
}