【数据结构】队列的实现及应用和循环队列的实现【完整版】

目录

一、队列的概念及结构

二、队列的实现

1.队列的初始化--QueueInit

2.队列的插入--QueuePush

3.判断队列是否为空--QueueEmpty

4.删除队列的元素--QueuePop

5.队列的长度--QueueSize

6.找队列的队头--QueueFront

7.找队列的队尾--QueueBack

8.销毁队列--QueueDestroy

三、队列的实际应用

四、队列的几道经典编程题

五、概念选择题

---

一、队列的概念及结构

相比栈，队列的特性和栈是相反的。
它只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO (First In First Out) 的特性。
入队列：进行插入操作的一端称为队尾；出队列：进行删除操作的一端称为队头
对于队列来说，一种入队顺序，只有一种出队顺序

二、队列的实现

那么队列用数组还是链式的结构呢？因为队列的性质是队头出，队尾进，所以用数组的话，你插入或者删除数据需要挪动数据，就很麻烦，所以这里用链表很简单。那这里为什么还要定义tail尾指针呢，之前单链表的定义却不用尾指针，因为单链表的尾插有尾指针很方便，但是尾删却很麻烦，这里的队列推荐用尾指针，因为队列的删除只能从队头删，所以不存在删尾指针的操作，这里用尾指针就很方便了，那么既然是既有头指针又有尾指针，属于不同类型的数，那么就可以定义一个结构体来放这两个指针

接下来就是实现函数功能，但是为什么不需要传二级指针呢？因为是定义的是结构体里面放的两个指针，那么你要改变的是这个结构体，你就需要传这个结构体的地址就可以。【注：队列的链表实现是没有头结点的】

typedef int QDataType;

typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

1.队列的初始化--QueueInit

void QueueInit(Queue* pq)
{
	assert(pq);
	//这里断言是因为你传入的结构体一定不能为空
	//那么他都是结构体了，还能为空？顶多可以说这个结构体里面的两个指针是NULL
	//这是为了避免你传错了，所以用assert
	pq->head = NULL;
	pq->tail = NULL;
}

---

2.队列的插入--QueuePush

队列只允许从队尾插入，从队头删除，所以就相当于只允许尾插的意思了，那么队列用链表实现了，尾插的操作也就不难，就是需要考虑如果队列中没有元素时这一特殊情况不能对NULL解引用 ，即可以用if else操作

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	//malloc空间,如果需要频繁的开辟空间建议实现一个CreateQueueNode函数用于malloc
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("malloc fail!\n");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->data = x;
	if (pq->tail == NULL)
	{
		pq->tail = pq->head = newnode;
	}
	else 
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	
}

---

3.判断队列是否为空--QueueEmpty

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	//空链表返回true，非空链表返回false
	return pq->head == NULL;
}

---

4.删除队列的元素--QueuePop

因为队列只允许队头删除，所以每次删除需要改变头指针的位置，再就是删除必须考虑的问题就是队列为空就不能继续往下删了。还有一个问题就是，如果你这个队列删完了，删之前head和tail都指向同一个空间（节点），也就是只剩一个节点时你删除。pq->head = NULL了，但是tail没有置NULL，那他就是野指针了！那么你后面如果再使用tail，一定会引发非法访问内存的问题，所以这里需要处理一下。

(#`O′)回顾一下造成野指针的常见问题：

1、指针未初始化---位置为随机值，即野指针

2、指针越界访问---指针指向的范围超过了本应指向的范围

3、指针指向的空间释放了---可你还在访问 

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//不管怎么删，为空了就不能删！推荐assert这种粗暴的方式
	QueueNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{//如果head为空了，就说明链表被删完了
	//但是tail他的此时为野指针，所以要把
	//它赋值为NULL
		pq->tail = NULL;
	}
}

---

5.队列的长度--QueueSize

遍历这个队列（链表）一遍，直到走到头，每走一个节点就sz++

int QueueSize(Queue* pq)
{
	assert(pq);
	int sz = 0;
	QueueNode* cur = pq->head;
	while (cur != NULL)
	{
		sz++;
		cur = cur->next;
	}
	return sz;
}

---

6.找队列的队头--QueueFront

这个函数的意思是，你要找到队头，并返回队头的数据域，那这个大前提肯定就是队列不能为空了

QDataType QueueFront(Queue* pq)
{
	assert(pq);//防止你传入的不是结构体，直接报错
	assert(!QueueEmpty(pq));//队列为空就不需要找队头这个操作了
	return pq->head->data;
}

---

7.找队列的队尾--QueueBack

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}

---

8.销毁队列--QueueDestroy

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//最后节点删除完，头尾指针一定要都置为NULL
	pq->head = pq->tail = NULL;
}

 完整代码
需要三个文件 

① Queue.h，用于函数的声明

② Queue.c，用于函数的定义

③ test.c，用于测试函数

 Queue.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int QDataType;

typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

void QueueInit(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
bool QueueEmpty(Queue* pq);
void QueuePop(Queue* pq);
QDataType  QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
void QueueDestory(Queue* pq);

 Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queque.h"

void QueueInit(Queue* pq)
{
	assert(pq);
	//这里断言是因为你传入的结构体一定不能为空
	//那么他都是结构体了，还能为空？顶多可以说这个结构体里面的两个指针是NULL
	//这是为了避免你传错了，所以用assert
	pq->head = NULL;
	pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	//malloc空间,如果需要频繁的开辟空间建议实现一个CreateQueueNode函数用于malloc
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("malloc fail!\n");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->data = x;
	if (pq->tail == NULL)
	{
		pq->tail = pq->head = newnode;
	}
	else 
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	//空链表返回true，非空链表返回false
	return pq->head == NULL;
}
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//不管怎么删，为空了就不能删！推荐assert这种粗暴的方式
	QueueNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{//如果head为空了，就说明链表被删完了
	//但是tail他的此时为野指针，所以要把
	//它赋值为NULL
		pq->tail = NULL;
	}
}
QDataType QueueSize(Queue* pq)
{
	assert(pq);
	int sz = 0;
	QueueNode* cur = pq->head;
	while (cur != NULL)
	{
		sz++;
		cur = cur->next;
	}
	return sz;
}
QDataType QueueFront(Queue* pq)
{
	assert(pq);//防止你传入的不是结构体，直接报错
	assert(!QueueEmpty(pq));//队列为空就不需要找队头这个操作了
	return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//最后节点删除完，头尾指针一定要都置为NULL
	pq->head = pq->tail = NULL;
}

 test.c 

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queque.h"
int main()
{
	//1、传二级指针
	//2、返回值
	//3、带哨兵位的头节点
	//4、嵌套结构体 (这里使用这种方式)
	Queue q;
	//初始化
	QueueInit(&q);
	//插入
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	//删除
	QueuePop(&q);
	QueuePop(&q);
	//取头
	QueueFront(&q);
	//取尾
	QueueBack(&q);
	//打印
	while (!QueueEmpty(&q))
	{
		QDataType front = QueueFront(&q);
		printf("%d", front);
		QueuePop(&q);
	}
	printf("\n");
	//释放
	QueueDestroy(&q);

	return 0;
}

三、队列的实际应用

 ①生产者消费者模型比如医院、营业厅、银行会用队列实现抽号机，保证公平性，先到的人先得到号。那如果两个人同时取号这种情况就需要以后学的加锁（这里用的是互斥锁），需要指令集，保证肯定是一个人先取到。这个人出来了才能解锁，另一个人才能取到。

队列的拓展：
实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以使用循环队列。环形队列可以使用数组实现，也可以使用循环链表实现。

关于环形队列在下面的的栈和队列面试题中会讲

四、队列的几道经典编程题

1、用队列实现栈 --力扣 难度：简单

 题述：请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

❶ void push(int x) 将元素 x 压入栈顶。

❷ int pop() 移除并返回栈顶元素。

❸int top() 返回栈顶元素。

❹ boolean empty() 如果栈是空的，返回 true ；否则，返回 false

⚠ 注意

① 你只能使用队列的基本操作——也就是push to back、peek/pop from front、size和is empty这些操作。并且你不能改变队列结构，只能去调用队列提供的接口函数去实现

② 你所使用的语言也许不支持队列。你可以使用list (列表) 或者deque (双端队列) 来模拟一个队列，只要是标准的队列操作即可。

💨 示例：
输入：
[“MyStack”, “push”, “push”, “top”, “pop”, “empty”] - 调用函数接口简称
[[], [1], [2], [], [], []] - 参数
输出：
[null, null, null, 2, 2, false]
解释：
MyStack myStack = new MyStack();//我的这个栈应该包括两个队列的意思
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

 提示 

 ❶1 <= x <= 9

❷ 最多调用100 次 push、pop、top 和 empty

❸ 每次调用 pop 和 top 都保证栈不为空

⚜ 进阶
你能否实现每种操作的均摊时间复杂度为 O(1) 的栈？换句话说，执行 n 个操作的总时间复杂度 O(n) ，尽管其中某个操作可能需要比其他操作更长的时间。你可以使用两个以上的队列。

🧷 平台：Visual studio 2017 && windows

🔑 核心思想：队列的数据是不能从队尾出的，只能从队头出，而这里要实现的是队列实现栈，所以只能遵循栈的特性——后进先出。这里就需要另外一个队列，具体步骤如下：

1、使一个队列有数据，一个队列没数据

2、入数据时向不为空的那个入，保持另一个队列为空

3、出数据时，就将不为空的队列的前 size-1 个数据拷贝至另一个队列保存，然后再Pop掉非空队列剩下的一个数据，因为对于队列来说，直接出是无法实现后进先出的，所以要先把前面size-1个数据先导入另一个队列中（保证数据不丢），剩下那一个数据利用队列的性质直接pop掉就可以实现后进先出了

^(*￣(oo)￣)^ 注意：

1、因为我们是用c写的，这相比用c++的库的直接调用会麻烦

2、这道题的实际意义并不大，但是主要考察你对栈和队列的性质的理解，因为他们俩的性质相反，那我们可以用两个先进先出的队列实现一个后进先出性质的栈

下面是删除的结构，因为我们动态开辟了两个结构体大小的空间，一个空间是结构体mystack用来放两个队列q1.q2的，还有一份空间是q1指向的链表的空间和q2指向的链表的空间，因为两个链表的节点都是动态开辟来的，所以最后释放需释放两部分

 3、一定注意->的优先级是大于&的，不然下面的实现你很容易混淆的！

综上：代码如下。需要注意的是这里两个队列实现栈的情况是需要在之前写的队列的实现的基础上来进一步实现的，但是如果你用c++，就直接调用库函数就可以来进一步实现，这也是c的缺点之一了

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int QDataType;

typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

void QueueInit(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
bool QueueEmpty(Queue* pq);
void QueuePop(Queue* pq);
QDataType  QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
void QueueDestory(Queue* pq);
#define _CRT_SECURE_NO_WARNINGS 1
#include"Queque.h"

void QueueInit(Queue* pq)
{
	assert(pq);
	//这里断言是因为你传入的结构体一定不能为空
	//那么他都是结构体了，还能为空？顶多可以说这个结构体里面的两个指针是NULL
	//这是为了避免你传错了，所以用assert
	pq->head = NULL;
	pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	//malloc空间,如果需要频繁的开辟空间建议实现一个CreateQueueNode函数用于malloc
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("malloc fail!\n");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->data = x;
	if (pq->tail == NULL)
	{
		pq->tail = pq->head = newnode;
	}
	else 
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	//空链表返回true，非空链表返回false
	return pq->head == NULL;
}
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//不管怎么删，为空了就不能删！推荐assert这种粗暴的方式
	QueueNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{//如果head为空了，就说明链表被删完了
	//但是tail他的此时为野指针，所以要把
	//它赋值为NULL
		pq->tail = NULL;
	}
}
QDataType QueueSize(Queue* pq)
{
	assert(pq);
	int sz = 0;
	QueueNode* cur = pq->head;
	while (cur != NULL)
	{
		sz++;
		cur = cur->next;
	}
	return sz;
}
QDataType QueueFront(Queue* pq)
{
	assert(pq);//防止你传入的不是结构体，直接报错
	assert(!QueueEmpty(pq));//队列为空就不需要找队头这个操作了
	return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//最后节点删除完，头尾指针一定要都置为NULL
	pq->head = pq->tail = NULL;
}


typedef struct {
	Queue q1;//队列1
	Queue q2;//队列2
} MyStack;//将这个匿名结构体类型名字typedef为MyStack

/** Initialize your data structure here. */
MyStack* myStackCreate() {
	//我的这个栈应该包含两个队列的意思，用两个队列实现栈
	//malloc空间，因为如果不动态开辟，返回pst会是局部变量的地址，出了函数就会销毁的
	//所以这里最好动态开辟，可以返回你开辟的地址
	MyStack* pst = (MyStack*)malloc(sizeof(MyStack));//创建一个pst它指向两个队列
	//初始化两个队列
	QueueInit(&pst->q1);//这里因为->优先级大于&的优先级，所以是先拿到q1这个队列，因为是Queue类型的，所以要&变成指针再初始化
	QueueInit(&pst->q2);
	return pst;
	//返回pst后这个MyStack就创建好了
}

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) {
	assert(obj);
	//QueueEmpty为空时返回true，不为空时返回false
	//往不为空的那个队列里插入数据(q1不为空往q1插入，q2不为空往q2插入，两个都为空则往任      
	//意一个插入就可以,核心就是保持其中一个有数据，另一个没数据即可
	if (!QueueEmpty(&obj->q1))
	{//队列1不为空的话，就往队列1插入数据的意思
		QueuePush(&obj->q1, x);
	}
	else
	{
		QueuePush(&obj->q2, x);
	}
}

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) {
	assert(obj);

	//因为我们不知道哪个为空，所以
	//先默认q1为空，q2不为空，类似于之前讲的链表相交面试题中的某个操作
	Queue* emptyQ = &obj->q1;
	Queue* nonemptyQ = &obj->q2;
	//q1不为空，重新赋值（假设错误的话的操作）
	if (!QueueEmpty(&obj->q1))
	{
		emptyQ = &obj->q2;
		nonemptyQ = &obj->q1;
	}
	//拷贝 - 将非空队列的size-1个数据拷贝
	while (QueueSize(nonemptyQ) > 1)
	{
		//将非空的队列拷贝至空的队列
		QueuePush(emptyQ, QueueFront(nonemptyQ));//取队头的数据导进去，注意这里不是mystackpush，而是对队列操作！用QueuePush
		//删除迭代
		QueuePop(nonemptyQ);
	}
	//top记录非空队列的剩下一个值，因为题目要求了Pop后要返回被移除的栈顶元素
	int top = QueueFront(nonemptyQ);
	//删除非空队列的剩下一个数据，这个数据就是栈顶的数据
	QueuePop(nonemptyQ);
	//返回
	return top;
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
	//这个函数就是找栈的栈顶的意思，那么栈顶就相当于队列的队尾了
	assert(obj);
	//这里不需要把队列导入另一个队列，因为队列的队头和队尾都是可以直接取到的
	//但是我不知道哪个队列有数据，所以要判断，因为我们假设了始终一个队列有数据，另一个队列没数据
	//q1不为空，取q1的数据
	if (!QueueEmpty(&obj->q1))
	{
		return QueueBack(&obj->q1);
	}
	//q2不为空，取q2的数据
	else
	{
		return QueueBack(&obj->q2);
	}
}

/** Returns whether the stack is empty. */
bool myStackEmpty(MyStack* obj) {
	assert(obj);

	//只有两个队列都不为空，这个栈才不为空
	//q1和q2一定有一个为空
	//q1为空返回真，q2为空返回真，mystackEmpty为空返回真;
	//q1为空返回真，q2为非空返回假，myStackEmpty为非空，返回假
	//q1为非空返回假，q2为空返回真，myStackEmpty为非空，返回假
	return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
	assert(obj);
	//结合上面的代码分析我们需要回收两个队列和myStackcreate里malloc的空间
	//就是先释放两个队列，因为两个队列是链表构成的，而链表的每个节点又是malloc出来的
	//然后再释放指向两个队列的指针，因为他也是malloc出来的，obj即pst
	//pst是之前malloc出来的一个结构体指针，指向这个含有两个队列的结构体，所以也要释放
	QueueDestroy(&obj->q1);
	QueueDestroy(&obj->q2);

	free(obj);
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

 2、用栈实现队列 --力扣 难度：简单

 题述：请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

❶ void push(int x) 将元素 x 推到队列的末尾。

❷ int pop() 从队列的开头移除并返回元素。

❸ int top() 返回队列开头的元素。

❹ boolean empty() 如果队列是空的，返回 true ；否则，返回 false

⚠ 注意
①你只能使用标准的栈操作 —— 也就是只有push to top，peek/pop from top，和 is empty 操作是合法的。

② 你所使用的语言也许不支持栈。你可以使用 list 或者 deque (双端队列) 来模拟一个栈，只要是标准的栈操作即可。

⚜ 进阶

你能否实现每个操作均摊时间复杂度为0(1)的队列?换句话说，执行 n 个操作的总时间复杂度为o(n)，即使其中一个操作可能花费较长时间。

💨 示例：
输入：
[“MyQueue”, “push”, “push”, “peek”, “pop”, “empty”] - 调用函数接口简称
[[], [1], [2], [], [], []] - 参数
输出：
[null, null, null, 1, 1, false]
解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

 提示

❶1 <= x <= 9

❷最多调用100 次 push、pop、top 和 empty

❸ 假设所有操作都是有效的 (例如，一个空的队列不会调用 pop 或者 peek 操作)

🧷 平台：Visual studio 2017 && windows

🔑 核心思想：怎么用两个栈实现一个先进先出的队列呢？

①入数据，进 pushst

②出数据，看 popst 是否为空，如果为空，就先把 pushst 的数据导入Popst，然后出数据；如果不为空，则直接出 popst 的数据

从①和②两个操作，我们就可以用两个栈实现队列先进先出的性质

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef char STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;//栈顶的位置
	int capacity;
}ST;

void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps,STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);//找栈顶的函数
int StackSize(ST* ps);
bool StackEmpty(ST* ps);

typedef struct {
	ST pushST;
	ST popST;
} MyQueue;
#include"Stack.h"
void StackInit(ST* ps)
{
	assert(ps);//传入的结构体指针不能为空
	ps->a = NULL;
	ps->top = 0;//也可以写成ps->top = -1;
	ps->capacity = 0;
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//满了是要扩容的
	if (ps->capacity == ps->top)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);//程序异常退出
		}
		ps->capacity = newCapacity;
		ps->a = tmp;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//如果为空返回1 那么即！1为0 assert判断为假，直接报错
	// 所以你传入的这个栈不能为空栈
	//删除的数据个数不能<top
	ps->top--;
}
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//也可以写成assert(ps->top > 0);
	//但更建议这种用函数的写法，因为万一top初始化为-1，这里还需要改。
	//因为这道题我初始化top为0，所以不用改
	//因为为空就不需要找这个栈顶了

	return ps->a[ps->top - 1];
	//这里因为初始化top=0，所以栈顶应该是对应top-1才对
}
void StackDestroy(ST* ps)
{
	assert(ps);
	if (ps->a)
	{
		free(ps->a);
	}
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}
bool StackEmpty(ST* ps)
{/*下面这种第一个写法比较麻烦
	assert(ps);
	if (ps->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/
	return ps->top == 0;//这种写法很简单
}
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

/** Initialize your data structure here. */
//malloc空间
MyQueue* myQueueCreate() {
	//malloc一块MyQueue类型大小的空间
	MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
	//初始化
	StackInit(&q->pushST);//注意->的优先级是大于&的！！
	StackInit(&q->popST);
	//返回MyQueue这块空间的地址 
	return q;
}

/** Push element x to the back of queue. */
//插入
void myQueuePush(MyQueue* obj, int x) {
	assert(obj);
	//往pushST这个结构体里插入
	StackPush(&obj->pushST, x);
}

/** Get the front element. */
//取队头，按照题目要求规定设置为myQueuePeek函数名
int myQueuePeek(MyQueue* obj) {
	assert(obj);
	//如果popST为空，则将pushST的数据导入popST，再取队头
	//这里和删除的思想一样，你要取队头要先保证popST中有数据
	//没有就先导入数据
//如果popst中有数据，那么直接删除popst的栈顶即可，因为符合先进先出的性质
	if (StackEmpty(&obj->popST))
	{
		//popST内有数据，返回false，再非
		while (!StackEmpty(&obj->pushST))
		{
			//把pushST栈顶的数据插入至popST
			StackPush(&obj->popST, StackTop(&obj->pushST));
			//迭代
			StackPop(&obj->pushST);
		}
	}
	//如果popST不为空，直接取队头
	return StackTop(&obj->popST);
}

/** Removes the element from in front of queue and returns that element. */
//删除
int myQueuePop(MyQueue* obj) {
	assert(obj);
	//如果popST为空，则将pushST的数据导过去
	//popST中的数据就符合先进先出的顺序了
	//因为我们插入是往pushST栈中插入数据
	//而删除是把pushST中的数据导入popST后，再删除popST的栈顶
	//所以popST中的数据一定是由pushST中的数据导入进来的
	if (StackEmpty(&obj->popST))
	{//不为空就不会进来，就说明pushST中的数据已经导入进PopST中了
	 //为空的话你删除就要先导入数据才可以
		//popST内有数据，返回false，再非
		while (!StackEmpty(&obj->pushST))
		{
			//把pushST栈顶的数据插入至popST
			StackPush(&obj->popST, StackTop(&obj->pushST));
			//迭代
			StackPop(&obj->pushST);
		}
	}
	//备份popST内栈顶的数据，用于返回
	int front = StackTop(&obj->popST);
	//如果popST不为空，直接出数据
	StackPop(&obj->popST);
	//返回popST栈顶的数据
	return front;
}

/** Returns whether the queue is empty. */
//判空
bool myQueueEmpty(MyQueue* obj) {
	assert(obj);
	//pushST和popST同时为空，才为空
	return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);
}

//释放销毁
void myQueueFree(MyQueue* obj) {
	assert(obj);
	//上面的代码中，我们先malloc了一块MyQueue类型的空间，在插入的操作接口中又malloc了pushST和popST
	StackDestroy(&obj->pushST);
	StackDestroy(&obj->popST);
	free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

3、设计循环队列（环形队列） --力扣 难度：中等

 题述：设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。（因为是固定大小了，所以实现环形队列我们一般用动态开辟数组实现，但是主要还是因为环形队列用数组实现具有相对的优势）

你的实现应该支持如下操作：
1️⃣ MyCircularQueue(k): 构造器，设置队列长度为 k 。

2️⃣ Front: 从队首获取元素。如果队列为空，返回 -1 。

3️⃣ Rear: 获取队尾元素。如果队列为空，返回 -1 。

4️⃣ enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。

5️⃣ deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。

6️⃣ isEmpty(): 检查循环队列是否为空。

7️⃣ isFull(): 检查循环队列是否已满。

💨 示例：
MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1); // 返回 true
circularQueue.enQueue(2); // 返回 true
circularQueue.enQueue(3); // 返回 true
circularQueue.enQueue(4); // 返回 false，队列已满
circularQueue.Rear(); // 返回 3
circularQueue.isFull(); // 返回 true
circularQueue.deQueue(); // 返回 true
circularQueue.enQueue(4); // 返回 true
circularQueue.Rear(); // 返回 4

提示

❶所有的值都在 0 至 1000 的范围内；

❷操作数将在 1 至 1000 的范围内；

❸ 请不要使用内置的队列库。

🧷 平台：Visual studio 2017 && windows

 ☸核心思想：

环形链表的特殊性就在于1、符合先进先出 2、空间大小是固定的，所以构建循环链表都会给定长度为k个，也就是最多能存k个数据，也就是说我们先会开辟好空间。所谓循环队列可以形象地认为是一个固定大小的队列，他循环就是能把之前用过的空间重复利用的意思。

问题一，使用数组还是链表

这里使用数组和链表都可以，但是使用数组的缓存利用率更高，且用链表(单链表)实现某些接口时相等比较麻烦，都是各有优劣的，这里我们用数组实现
问题二，数组和链表怎么构成环形 

1、需要两个指针，front指向下标0，tail指向下标k-1(k为数组有效长度)，tail只要超过数组长度，就回到front的位置，这里需要取模运算
2、让链表的最后一个节点不再指向空，而是指向第一个节点（如果用链表实现循环队列的话）

并且我们规定，插入数据时，先插入数据，然后tail++，同理，删除数据时，我们直接让front++。

问题三，怎么判断满与不满，空与非空

如果front 和 tail 都是指向起始位置，说明为空；可是当tail==front时出现可以说明满的情况，那就无法区分满和空的状态，为了区分，我们会多开辟一块空间，即存k个数据的循环队列，要开k+1个空间，否则无法区分判空和判满。结论：tail==front则为空，（tail+1）%（k+1）== front则为满。

（*重点*）着重说一下满的情况下（在k+1个空间的前提下）：

当tail<front时，tail+1 == front为真

当tail>front时，tail本来就比front大，tail+1肯定更大，但是会出现tail>front且队列满的情况，此时只要（tail+1）%（k+1） == front为真就是满的状态

而（tail+1）%（k+1）在tail<front的状态下依然是成立的，所以我们干脆就把判断满的情况写成（tail+1）%（k+1）== front  为真就是满，为假就是不满。

问题四，怎么找队尾 

我们下面用数组来实现循环队列，注意下面代码中rear就是tail，尾的意思，都是一样的

typedef struct {
	int* a;//指向开辟的空间
	int front;//首的下标
	int rear;//尾的下标
	int k; //环形队列的大小
} MyCircularQueue;

//开辟空间
MyCircularQueue* myCircularQueueCreate(int k) {
	//先malloc一块MyCircularQueue类型的空间
	MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	//再malloc指定的k个int类型的空间(注意这里需要额外一块空间)
	q->a = (int*)malloc(sizeof(int) * (k + 1));
	//初始化
	q->front = 0;
	q->rear = 0;
	q->k = k;
	//返回结构体的地址
	return q;
}

//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
	assert(obj);
	//当front等于rear时，队列为空
	return obj->front == obj->rear;
}

//判满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
	assert(obj);
	//当front等于rear+1时则为满(但要防止rear+1越界)
	return (obj->rear + 1) % (obj->k + 1) == obj->front;
}

//插入数据 - 不能插入返回false，能插入返回true
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
	assert(obj);
	//myCircularQueueIsFull判断队列是否为满
	//满了，就无须插入了，直接返回false（题目要求的可以这么做）
	if (myCircularQueueIsFull(obj))
		return false;

	//不满，插入数据，我们是先插入数据，再rear++
	obj->a[obj->rear] = value;
	obj->rear++;

	//当数组的最后一块空间插入数据时，rear++会越界
	//因为这个是循环队列，你需要把rear重新指向头
    //然后再判断满没满，如果满了就无须插入了
    //法一、取模
    //obj->rear %= (obj->k + 1);
    //法二、直接判断
	if (obj->rear == obj->k + 1)
		obj->rear = 0;
	//至此，返回真
	return true;
}

//删除数据 - 不能删除返回false，能删除返回true
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
	assert(obj);
	//myCircularQueueIsEmpty判断队列是否为空
	//空了，直接返回false
	if (myCircularQueueIsEmpty(obj))
		return false;

	//不空，删除数据，(这里只需要让front往后走即可)
	obj->front++;

	//当数组的最后一块空间删除数据时，front++会越界
	//所以让front返回到头，为什么要返回到头？
    //因为你可能会进行下一次的插入，那么再进行删除的时候
    //front肯定还要从头开始移动，因为是循环队列
	if (obj->front == obj->k + 1)
		obj->front = 0;

	return true;

	//最后这里也可以写成
	//obj->front %= (obj->k + 1);
	//return true;
}

//获取队头的数据 
int myCircularQueueFront(MyCircularQueue* obj) {
	assert(obj);
	//如果队列为空返回-1
	if (myCircularQueueIsEmpty(obj))
		return -1;
	//返回队头
	return obj->a[obj->front];
}

//获取队尾的数据 
//队尾元素可以认为是rear的前一个元素，但是有一种特殊情况
int myCircularQueueRear(MyCircularQueue* obj) {
	assert(obj);
	//如果队列为空返回-1
	if (myCircularQueueIsEmpty(obj))
		return -1;

	//获取队尾(这里myCircularQueueEnQueue插入数据后tail++，所以队尾是tail)
	//prevRear记录前一个
	int prevRear = obj->rear - 1;
	//当rear是下标为0的那块空间时，prevRear就是k
	if (obj->rear == 0)
		prevRear = obj->k;
	//返回队尾
	return obj->a[prevRear];

	//最后这里也可以写成
	//int i = (obj->rear + obj->k) % (obj->k + 1);
	//return obj->a[i];
}

//回收空间
void myCircularQueueFree(MyCircularQueue* obj) {
	assert(obj);
	//在上面的代码中我们malloc了两次的空间，先回收结构体内成员的空间，再回收结构体
	free(obj->a);
	free(obj);
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

五、概念选择题

1、循环队列的存储空间为 Q(1:100) ，初始状态为 front=rear=100 。经过一系列正常的入队与退队操作后， front=rear=99 ，则循环队列中的元素个数为（ ）

A.  1

B.  2

C.  99

D.  0

📝 解析：D，当循环队列进行一系列操作后，front == rear 说明为空；front == rear+1 说明为满
2、以下( )不是队列的基本运算？

A.  从队尾插入一个新元素

B.  从队列中删除第i个元素

C.  判断一个队列是否为空

D.  读取队头元素的值

📝 解析：B，从队列的特性先进先出，后进后出即可知道答案
3、现有一循环队列，其队头指针为front，队尾指针为rear；循环队列长度为N，实际最多存储 N - 1 个数据。其队内有效长度为？（ ）

A.  (rear - front + N) % N + 1

B.  (rear - front + N) % N

C.  (ear - front) % (N + 1)

D.  (rear - front + N) % (N - 1)

📝 解析：B
这里分为两种情况：

1️⃣ 队列的有效长度是 (rear - front + N) % N == 3

对于第 1 种情况来说只需要 rear - front 即可，为什么还需要 +N 再 % N ❓❔
因为这里还有第 2 种情况，而仅仅是 rear - front 这个公式是不能满足第 2 种情况的

2️⃣ 队列的有效长度是 (rear - front + N) % N == 4

对于第 2 种情况来说只需要 rear + N - front 即可，为什么还需要 +N 再 % N ❓❔
因为本题是只有 1 个正确答案，所以还要顾虑到第 1 种情况，需要寻找能同时适用于两种情况的 1 个公式