笔记---队列

队列是具有一定操作约束的线性表，只能在一端插入，一端删除。数据的插入是入队列，删除是出队列，要满足先进先出的原则，就像去银行的一个窗口办理业务，先来的人先办理，后来的人排在队伍后面。

---

队列的顺序存储实现

队列的顺序存储结构通常由一个一维数组和一个记录队列头元素位置的变量front以及记录队尾元素位置的变量rear组成。

1.定义一个顺序队

#include<stdio.h>
#include<stdlib.h>
#define Maxsize 1000
typedef int ElemType;
struct QNode
{
 ElemType data[Maxsize];
 int rear;//记录队尾元素位置
 int front;//记录队头元素位置
};
typedef struct QNode* Queue;

2.创建一个空队列

Queue CreatQueue()//创建一个顺序队
{
 Queue PtrQ;
 PtrQ = (Queue)malloc(sizeof(struct QNode));
 PtrQ->front=PtrQ->rear=-1;
 return PtrQ;
}

3.判断队列是否为空和已满

int IsEmptyQ(Queue PtrQ)//判断是否为空
{
 return(PtrQ->front == PtrQ->rear);
}
int IsFullQ(Queue PtrQ)//判断是否已满
{
 return(PtrQ->rear == Maxsize - 1);
}

4.顺序队中入队和出队操作

void AddQ(Queue PtrQ, ElemType e)//队尾插入元素
{
 if (IsFullQ(PtrQ))
 {
  return;
 }
 else
 {
  PtrQ->rear++;
  PtrQ->data[PtrQ->rear] = e;
 }
}
int DeleteQ(Queue PtrQ,ElemType &e)//删除队头元素
{
 if (IsEmptyQ(PtrQ))
 {
  return 0;
 }
 else
 {
  PtrQ->front++;
  e = PtrQ->data[PtrQ->front];
  return 1;
 }
}

---

循环队列的存储实现

1.定义一个循环队列

#include<stdio.h>
#include<stdlib.h>
#define Maxsize 1000
typedef int ElemType;
struct QNode
{
 ElemType data[Maxsize];
 int rear;
 int front;
};
typedef struct QNode* Queue;

2.创建一个空的循环队列

Queue CreatQueue()//创建循环队列
{
 Queue PtrQ;
 PtrQ = (Queue)malloc(sizeof(struct QNode));
 PtrQ->front=PtrQ->rear=0;
 return PtrQ;
}

3.判断循环队列是否为空和已满

int IsEmptyQ(Queue PtrQ)//判断是否为空
{
 return(PtrQ->front == PtrQ->rear);
}
int IsFullQ(Queue PtrQ)//判断是否已满
{
 return((PtrQ->rear+1)%Maxsize==PtrQ->front);
}

4.循环队中的入队和出队操作

void AddQ(Queue PtrQ, ElemType e)//入队
{
 if (IsFullQ(PtrQ))
 {
  return;
 }
 else
 {
  PtrQ->rear=(PtrQ->rear+1)%Maxsize;
  PtrQ->data[PtrQ->rear] = e;
 }
}
int DeleteQ(Queue PtrQ,ElemType &e)//出队
{
 if (IsEmptyQ(PtrQ))
 {
  return 0;
 }
 else
 {
  PtrQ->front=(PtrQ->front+1)%Maxsize;
  e = PtrQ->data[PtrQ->front];
  return 1;
 }
}

---

队列的链式存储实现

队列的链式存储结构也可以用一个单链表实现，插入和删除操作分别在链表的两头进行。

1.定义一个链队

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
struct Node
{
 ElemType data;
 struct Node* next;
};
struct QNode 
{
 struct Node* rear;
 struct Node* front;
};
typedef struct QNode* Queue;
Queue PtrQ;

2.创建一个空的链队

Queue CreatQueue()//创建一个空的链队
{
 PtrQ = (Queue)malloc(sizeof(struct QNode));
 PtrQ->front = PtrQ->rear = NULL;
}

3.判断一个链队是否为空

int IsEmpty()//判断是否为空不考虑已满的情况
{
 return(PtrQ->rear == NULL);
}

4.链队的入队和出队操作

void AddQ(ElemType e)//入队
{
 struct Node* p;
 p = (struct Node*)malloc(sizeof(struct Node));
 p->data = e;
 p->next = NULL;
 if (IsEmpty)
 {
  PtrQ->front = PtrQ->rear = p;
 }
 else
 {
  PtrQ->rear->next = p;
  PtrQ->rear = p;
 }
}

int DeleteQ(ElemType& e)//出队
{
 struct Node* p;
 if (IsEmpty)
 {
  return 0;
 }
 p = PtrQ->front;
 if (PtrQ->front == PtrQ->rear)//队列中只有一个元素
 {
  PtrQ->front = PtrQ->rear=NULL;
 }
 else
 {
  PtrQ->front = PtrQ->front->next;
 }
 e = p->data;
 free(p);
 return 1;
}

---

本文资源来自慕课，方便复习。