3.2 栈和队列-队列

链接: https://gitee.com/michael_linux/data-struct-study.git

1、队列的类型定义

ADT Queue{
数据对象：
D = { a i ∣ a i ∈ E l e m S e t ;   i = 1 , 2 , . . . , n ;   n ⩾ 0 } D=\{a_{i} | a_{i} \in ElemSet; \ i=1,2,...,n;\ n \geqslant 0\} D={ai​∣ai​∈ElemSet; i=1,2,...,n; n⩾0}

数据关系：
R 1 = { < a i − 1 , a i > ∣ a i − 1 , a i ∈ D ;   i = 1 , 2 , . . . , n } 约定 a 1 端为队列头， a n 端为队列尾。 \begin{aligned}R1=\{&<a_{i-1},a_{i}> | a_{i-1},a_{i} \in D;\ i=1,2,...,n\}\\ &约定a_{1}端为队列头，a_{n}端为队列尾。\end{aligned} R1={​<ai−1​,ai​>∣ai−1​,ai​∈D; i=1,2,...,n}约定a1​端为队列头，an​端为队列尾。​

基本操作：
基本操作:
InitQueue(&Q)
操作结果：构造一个空队列Q。

DestroyQueue(&Q)
初始条件：队列Q已存在。
操作结果：队列Q被销毁,不再存在。

QueueEmpty(Q)
初始条件：队列Q已存在。
操作结果：若Q为空队列,则返回TRUE,否则FALSE。

QueueLength(Q)
初始条件：队列Q已存在。
操作结果：返回Q的元素个数,即队列的长度。

GetHead(Q, &e)
初始条件：Q为非空队列。
操作结果：用e返回Q的队头元素。

ClearQueue(&Q)
初始条件：队列Q已存在。
操作结果：将Q清为空队列。

EnQueue(&Q, e)
初始条件：队列Q已存在。
操作结果：插入元素e为Q的新的队尾元素。

DeQueue(&Q, &e)
初始条件：Q为非空队列。
操作结果：删除Q的队头元素，并用e返回其值。

} ADT Queue

2、队列类型的实现

2.1、链队列：链式映象

//链队结点类型定义
typedef struct QNode {
	int data;//数据域
	struct QNode *next;//指针域
}QNode;

//链队类型定义
typedef struct LiQueue {
	struct QNode *front;//队头指针
	struct QNode *rear;//队尾指针
}LiQueue;//链队类型定义


void initQueue(LiQueue *&lqu){
	lqu=(LiQueue*)malloc(sizeof(LiQueue));
	lqu->front=lqu=>rear=NULL;
}

int isQueueEmpty(LiQueue *lqu){
	if(lqu->front==NULL || lqu->rear==NULL){
		return 1;
	}else{
		return 0;
	}
}

void enQueue(LiQueue *lqu, int x){
	QNode *p;
	p = (QNode*)malloc(sizeof(QNode));
	p->data=x;
	p->next=NULL;
	if(lqu->rear == NULL){//若队列为空，则新节点是队首节点，也是队尾结点；
		lqu->front=lqu->rear=p;
	}else{//将新节点链接到队尾，rear指向它
		lqu->rear->next=p;
		lqu->rear=p;
	}
}

int deQueue(Lilqueue *lqu, int &x){
	QNode *p;
	if(lqu->rear == NULL){
		return 0;
	}else{
		p=lqu->front;
	}
	
	if(lqu->front == lqu->rear){
		lqu->front = lqu->rear = NULL;
	}else{
		lqu->front=lqu->front->next;
	}
	x=p->data;
	free(p);
	return 1;
}

2.2、循环队列：顺序映象

#define MAX_Q_SIZE 100 //最大队列长度
typedef struct{
QElemType *base; //动态分配存储空间
int front; //头指针，若队列不空，指向队列头元素
int rear; //尾指针，若队列不空，指向队列尾元素的下一个位置
}SqQueue;

另一种描述：

//顺序队列定义
typedef struct {
	int data[maxSize];
	int front;//队首指针
	int rear;//队尾指针
}SqQueue;//顺序队类型定义


循环队列的要素
队空状态：qu.rear == qu.front
对满状态：(qu.rear)%maxSize == qu.front
进队操作：
qu.rear = (qu.rear+1)%maxSize;
qu.data[qu.rear]=x;
出队操作：
qu.front=(qu.front+1)%maxSize;
x=qu.data[qu.front];


void initQueue(SqQueue &qu){
	qu.front=qu.rear=0;//队首和队尾指针重合，并且指向0；
}

int isQueueEmpty(SqQueue qu){
	if(qu.front == qu.rear){//不论队首队尾指针指向数组中的哪个位置，只要两者重合，即为队空。
		return 1;
	}else{
		return 0;
	}
}

int enQueue(SqQueue &qu, int x){
	if((qu.rear+1)%maxSize == qu.front){//队满
		return 0;
	}
	
	qu.rear = (qu.rear+1)%maxSize;
	qu.data[qu.rear]=x;
	return 1;
}


int deQueue(SqQueue &qu, int &x){
	if(qu.front == qu.rear){//若队空，则不能出队
		return 0;
	}
	qu.front = (qu.front+1)%maxSize;
	x=qu.data[qu.front];
	return 1;
}

// 静态链表 循环链表
# include <stdio.h>
# include <malloc.h>

typedef struct Queue{
	int * pBase;
	int front;
	int rear;
}QUEUE;  

void init(QUEUE *);
bool en_queue(QUEUE *, int val);  //入队
void traverse_queue(QUEUE *);
bool full_queue(QUEUE *);
bool out_queue(QUEUE *, int *);
bool empty_queue(QUEUE *);

int main(void)
{
	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);
	en_queue(&Q, 7);
	en_queue(&Q, 8);

	traverse_queue(&Q);

	if ( out_queue(&Q, &val) )
	{
		printf("出队成功，队列出队的元素是: %d\n", val);
	}
	else
	{
		printf("出队失败!\n");
	}
	traverse_queue(&Q);

	return 0;
}

void init(QUEUE *pQ)
{
	pQ->pBase = (int *)malloc(sizeof(int) * 6);
	pQ->front = 0;
	pQ->rear = 0;
}

bool full_queue(QUEUE * pQ)
{
	if ( (pQ->rear + 1) % 6 == pQ->front  )
		return true;
	else
		return false;
}

bool en_queue(QUEUE * pQ, int val)
{
	if ( full_queue(pQ) )
	{
		return false;
	}
	else
	{
		pQ->pBase[pQ->rear] = val;
		pQ->rear = (pQ->rear+1) % 6;

		return true;
	}
}

void traverse_queue(QUEUE * pQ)
{
	int i = pQ->front;

	while (i != pQ->rear)
	{
		printf("%d  ", pQ->pBase[i]);
		i = (i+1) % 6;
	}
	printf("\n");

	return;
}

bool empty_queue(QUEUE * pQ)
{
	if ( pQ->front == pQ->rear )
		return true;
	else
		return false;
}

bool out_queue(QUEUE * pQ, int * pVal)
{
	if ( empty_queue(pQ) )
	{
		return false;
	}
	else
	{
		*pVal = pQ->pBase[pQ->front];
		pQ->front = (pQ->front+1) % 6;

		return true;
	}
}

4、学习目标

1. 掌握栈和队列类型的特点，并能在相应的应用问题中正确选用它们。
2. 熟练掌握栈类型的两种实现方法，特别应注意栈满和栈空的条件以及它们的描述方法。
3. 熟练掌握循环队列和链队列的基本操作实现算法，特别注意队满和队空的描述方法。
4. 理解递归算法执行过程中栈的状态变化过程。

---