数据结构与算法学习笔记：循环队列、链式队列的实现、双端队列（重理论）

“typedef_queue":

#pragma once
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#define MaxSize 50

//本质：操作受限的线性表，注意，本质是线性表，只不过操作受限
/*逻辑结构描述FIFO
允许插入的一头是rear(只允许尾插）
允许删除的一头是front（只允许从队首删除）
*/


//顺序实现的循环队列定义
typedef struct
{
	int data[MaxSize];
	int front,rear;//队头和队尾游标
}SqQueue;






//链式队列的节点的定义
typedef struct LinkNode//这最好把名字给写上，否则会出现“不能将X*类型的值分配到X*类型的实体”的报错
{
	int data;
	struct LinkNode* next;
}LinkNode;

//链式队列的定义
typedef struct
{
	LinkNode* front, *rear;
}LinkQueue;


//双端队列
//输入或者输出受限的双端队列？重理论。

"functions_of_queue":

#pragma once
#include "typedef_queue.h"
#include <stdbool.h>


//循环顺序队列

//初始化
void InitQueue(SqQueue& Q)
{
	Q.rear = Q.front = 0;//较抽象，其实应该再具体的地方指向具体的内存单元
}



//设计case1：牺牲一个单元来区分队空队满
//判空队列
bool isEmpty(SqQueue Q)
{
	if (Q.rear == Q.front)return true;
	else return false;
}
//判队列满
bool isFull(SqQueue Q)
{
	if ((Q.rear + 1) % MaxSize == Q.front)return true;//rear循环加1等于front则队满
	else return false;
}
//入队
bool enQueue(SqQueue& Q, int x)
{
	if ((Q.rear + 1) % MaxSize == Q.front)return false;
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1) % MaxSize;//入队后rear循环加一
	return true;
}
//出队
bool deQueue(SqQueue& Q, int& elem)
{
	if (Q.rear == Q.front)return false;
	elem = Q.data[Q.front];
	Q.front = (Q.front + 1) % MaxSize;//front端出队之后也是循环加一
	return true;
}


//设计case2：在定义队列结构时增设Q.size成员记录个数，判断个数和Maxsize和0的关系
// 该情况队空队满都有Q.rear==Q.front

//设计case3：在定义队列结构时增设tag，tag==0时队空，此时Q.rear==Q.front;
//tag==1时队满，此时因插入也有Q.rear==Q.front






//链式队列
//初始化
void InitQueue(LinkQueue& Q)
{
	Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));//建立头节点
	Q.front->next = NULL;
}
//判队空
bool isEmpty(LinkQueue Q)
{
	if (Q.front == Q.rear)return true;
	else return false;
}
//入队
bool enQueue(LinkQueue& Q, int x)
{
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = x;
	s->next = NULL;
	Q.rear->next = s;
	Q.rear = s;
}
bool deQueue(LinkQueue& Q, int& elem)
{
	if (Q.front == Q.rear)return false;
	//LinkNode* p = Q.front->next;
	elem = Q.front->next->data;
	Q.front->next = Q.front->next->next;
	if (Q.rear == Q.front->next)
		Q.rear = Q.front;
	free (Q.front->next);
	return true;
}


//双端队列