数据结构之队列

一 队列的定义

队列(Queue)：是一种先进先出(First In First Out ，简称FIFO)的线性表。只允许在表的一端front进行插入，而在另一端rear进行删除。
队首(front) ：允许进行删除的一端称为队首。
队尾(rear) ：允许进行插入的一端称为队尾。

二 队列的分类

队列可分为静态队列和链式队列两大类。其中静态队列是用数组形式实现的，为循环队列。

三 循环队列的讲解

3.1 在循环队列中需要两个参数确定 front为队头和rear为队尾
1>初始化
front和rear的值都为0
2>队列非空
front代表队列的第一个元素。
rear指向最后一个的下一个。
3>队列空
front=rear

3.2 入队算法
1>将值存入r所代表的位置
2>r=(r+1)%数组的长度

3.3 出队算法讲解
f=(f+1)%数组的长度

3.4 循环队列为空
front和rear的值相等，则一定为空

3.5 如何判断循环队列为满
通常我们会少用一个元素，即定义数组有6个元素，其中有一个元素用来存放rear，用来判断循环队列是否满。
即如果r和f紧挨着，则队列已满。
if（（r+1）%数组的长度==f）
已满
else
不满

四 静态队列代码

//静态队列  可用数组实现
#include<iostream>
#include<malloc.h>
#include<stdio.h>
using namespace std;
typedef struct QUEUE
{
 int *pBase;   //初始化内存分配空间。 
 int front;    //队头 
 int rear;     //队尾 
}queue,*Queue;
void init(Queue);  //队列初始化 
void en_queue(Queue,int); //入队
bool full(Queue); //队列是否满了 
bool out_queue(Queue,int *); //出队
bool empty(Queue);  //判断队列是否为空 
void traverse_queue(Queue); //输出便利 
int main()
{
 queue q;
 int val;
 init(&q);
 en_queue(&q,1);
 en_queue(&q,2);
 en_queue(&q,3);
 en_queue(&q,4);
 en_queue(&q,5);
 //en_queue(&q,6);
 traverse_queue(&q);
 if(out_queue(&q,&val))
 {
  cout<<"出队成功，出队的元素是："<<val<<endl; 
 }
 else 
 {
  cout<<"fail"<<endl;
 }
 return 0;
 } 
void init(Queue q)
{
 q->pBase=(int *)malloc(sizeof(int)*6);
 q->front=0;
 q->rear=0;
}
void en_queue(Queue q,int val)
{
 if(full(q))
 cout<<"队列已满"<<endl;
 else 
 {
  q->pBase[q->rear]=val;
  q->rear=(q->rear+1)%6;
 } 
}
bool full(Queue q)
{
 if(q->front==(q->rear+1)%6)
 return true;
 else 
 return false;
}
bool empty(Queue q)
{
 if(q->front==(q->rear))
 return true;
 else 
 return false; 
} 
bool out_queue(Queue q,int *val)
{
 if(empty(q))
 {
  cout<<"队列已空"<<endl;
  return false;
 }
 else
 {
  *val=q->pBase[q->front];
  q->front=(q->front+1)%6;
  return true;
  } 
}
void traverse_queue(Queue q)
{
 int i=q->front;
 while(i!=q->rear)
 {
  cout<<q->pBase[i];
  i=(i+1)%6;
 }
 cout<<endl;
}

五 链式队列代码

//链表队列 
#include<iostream>
#include<malloc.h>
#include<stdio.h>
using namespace std;
typedef struct node
{
 int data;
 struct node* next;
}Node,*NODE;
typedef struct queue
{
 NODE front;
 NODE rear;
}*Queue,QUEUE;
void init(Queue);//构造一个空队列 
void in_queue(Queue,int);//入队 
void traverse_queue(Queue); //输出便利 
void out_queue(Queue,int *);  //出队 
bool empty(Queue); //队列是否为空 
int main()
{
 QUEUE q;
 int val;
 init(&q);
 in_queue(&q,1);
 in_queue(&q,2);
 in_queue(&q,3);
 in_queue(&q,4);
 in_queue(&q,5);
 traverse_queue(&q);
 out_queue(&q,&val);
 cout<<val<<endl;
 
 return 0;
} 
 void init(Queue q)
 {
  q->front=(NODE)malloc(sizeof(node));  
  if(q->front==NULL)
  {
   printf("动态内存分配失败\n");
  exit(-1); 
 }
 else 
 {
  q->rear=q->front;
  q->front->next=NULL;
 }
 }
 void in_queue(Queue q,int val)//入队  链式队列不需要判断队列是否满了 
 {
  NODE pnew=(NODE)malloc(sizeof(node));
  pnew->data=val;
  pnew->next=NULL;
  q->rear->next=pnew;
  q->rear=pnew; 
  } 
void traverse_queue(Queue q) //输出便利 
{
 NODE p;
 p=q->front->next;
 while(p!=NULL)
 {
  cout<<p->data<<" ";
  p=p->next;  
 }
 cout<<endl; 
}
void out_queue(Queue q,int *val) //出队  要判断队列是否为空 
{
 if(empty(q))
 {
  cout<<"队列内没有元素"<<endl;
 }
 else 
 {
  NODE p=q->front->next;
  *val=p->data;
  q->front->next=p->next;
  if(q->rear==p)
  q->rear=q->front;
  free(p); 
 }
} 
bool empty(Queue q)
{
 if(q->front->next==NULL)
 return true;
 else 
 return false;
}