数据结构-队列

---

🦆 个人主页：深邃-

❄️专栏传送门：《C语言》《数据结构》

🌟Gitee仓库：《C语言》《数据结构》

---

队列目录

• 概念与结构
• • 概念
  • 队列底层结构选型
  • 队列结构
• 队列的实现
• • 初始化队列
  • 入队列
  • 判断队列是否为空
  • 出队列
  • 取队头数据
  • 取队尾数据
  • 队列有效元素个数
  • 队列的销毁
• 队列算法题
• • 用队列实现栈
  • • 栈结构
    • 创建一个栈
    • 入栈
    • 出栈
    • 取栈顶
    • 栈判空
    • 栈销毁
    • 测试提交

概念与结构

概念

概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)
入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端称为队头

队列底层结构选型

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低
相反链表标记头节点，尾节点，这样实现的队列，时间复杂度均为O(1)

队列结构

Q u e u e . h Queue.h Queue.h

typedef int QDataType;
//定义节点结构
typedef struct QueueNode {
	QDataType data;
	struct QueueNode* next;
}QueueNode;

//定义队列的结构
typedef struct Queue {
	QueueNode* phead; //队头
	QueueNode* ptail; //队尾
	//int size;         //队列中有效数据个数
}Queue;

接下来待实现的函数声明以及头文件 接下来待实现的函数声明以及头文件 接下来待实现的函数声明以及头文件

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
``//初始化
void QueueInit(Queue* pq);
//销毁
void QueueDesTroy(Queue* pq);
//入队列
void QueuePush(Queue* pq, QDataType x);
//出队列
void QueuePop(Queue* pq);
//取队头数据
QDataType QueueFront(Queue* pq);
//取队尾数据
QDataType QueueBack(Queue* pq);
//队列判断为空
bool QueueEmpty(Queue* pq);
//队列有效元素个数
int QueueSize(Queue* pq);

队列的实现

Q u e u e . c Queue.c Queue.c

初始化队列

//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
}

入队列

思路：创建一个节点，插入队列中，注意判断队列是否为空

//入队列
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	//创建值为x的节点
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	//队列为空
	if (pq->phead == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else {
		pq->ptail->next = newnode;
		pq->ptail = pq->ptail->next;
	}
}

判断队列是否为空

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead == NULL;
}

出队列

出队列，队头出，注意剩一个元素的特殊情况

//出队列
void QueuePop(Queue* pq)
{
	assert(!QueueEmpty(pq));

	//队列中只有一个节点
	if (pq->phead == pq->ptail)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else {
		QueueNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
}

取队头数据

//取队头数据
QDataType QueueFront(Queue* pq)
{
	assert(!QueueEmpty(pq));
	return pq->phead->data;
}

取队尾数据

//取队尾数据
QDataType QueueBack(Queue* pq)
{
	assert(!QueueEmpty(pq));
	return pq->ptail->data;
}

队列有效元素个数

//队列有效元素个数
int QueueSize(Queue* pq)
{
	assert(pq);
	QueueNode* pcur = pq->phead;
	int size = 0;
	while (pcur)
	{
		++size;
		pcur = pcur->next;
	}
	return size;

	//return pq->size;
}

优化思路：在队列中加入size元素

//定义队列的结构 
typedef struct Queue
{ 	
	QueueNode* phead; //队头
	QueueNode* ptail; //队尾 	
	int size;         //队列中有效数据个数 
}Queue; 

//队列有效元素个数
int QueueSize(Queue* pq)
{
	return pq->size;
}

队列的销毁

//销毁
void QueueDesTroy(Queue* pq)
{
	assert(pq);

	QueueNode* pcur = pq->phead;
	while (pcur)
	{
		QueueNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->phead = pq->ptail = NULL;
}

队列算法题

用队列实现栈

题目链接：用队列实现栈

• 题目讲解

思路：
入栈：往不为空的队列中插入数据
出栈：把不为空队列中前size-1个数据挪到另一个队列，再将最后一个数据出队列
取栈顶（不出数据）：找不为空的队列，返回队尾数据

栈结构

//两个队列实现一个栈
typedef struct {
	Queue q1;
	Queue q2;
} MyStack;

创建一个栈

//创建一个栈
MyStack* myStackCreate() {
	MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
	QueueInit(&pst->q1);
	QueueInit(&pst->q2);
	return pst;
}

入栈

void myStackPush(MyStack* obj, int x) {
	//往不为空的队列中插入数据
	if (!QueueEmpty(&obj->q1))
	{
		//q1
		QueuePush(&obj->q1, x);
	}
	else {
		//q2
		QueuePush(&obj->q2, x);
	}
}

出栈

int myStackPop(MyStack* obj) {
	//找不为空队列
	Queue* emp = &obj->q1;
	Queue* noneEmp = &obj->q2;
	if (QueueEmpty(&obj->q2))
	{
		emp = &obj->q2;
		noneEmp = &obj->q1;
	}
	//不为空队列前size-1个数据挪到空队列中
	while (QueueSize(noneEmp) > 1)
	{
		//取队头,入另一个队列
		QueuePush(emp, QueueFront(noneEmp));
		//出队头
		QueuePop(noneEmp);
	}
	//不为空队列数据出队
	int top = QueueFront(noneEmp);
	QueuePop(noneEmp);
	return top;
}

取栈顶

//取栈顶
int myStackTop(MyStack* obj) {
	//找不为空队列,返回不为空队列的队尾数据
	if (!QueueEmpty(&obj->q1))
	{
		return QueueBack(&obj->q1);
	}
	else {
		return QueueBack(&obj->q2);
	}
}

栈判空

bool myStackEmpty(MyStack* obj) {
	return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

栈销毁

void myStackFree(MyStack* obj) {
	QueueDesTroy(&obj->q1);
	QueueDesTroy(&obj->q2);
	free(obj);
	obj = NULL;
}

测试提交

---