1、队列的概念
队列是一种先进先出(First In First Out ,FIFO)的数据结构,可以简单理解为排队的概念。在队列中,数据项按照插入的顺序排列,并且只能在队列的一端插入(称为队尾),在另一端删除(称为队头)。
2、队列的结构
入队列:进行插入操作的一端称为队尾
出队列:进行删除操作的一端称为队头
如何选择合适的数据结构实现队列(数组or链表)
在前面学习的顺序表中,我们知道数组只有在尾插和尾删效率高为O(1),当需要对头部元素操作时效率较低为O(n)。队列的特点是在队尾插入元素,在队头删除元素,序列两端都需要访问,这就导致使用数组实现队列时必定有一端的插入(or删除)效率低,因此不建议使用数组实现队列。
3、队列的链式存储
通过上面的分析,我选择链式存储结构来实现队列。这是因为链式存储结构实现两端的高效访问很简单——只需要增加一个尾指针即可实现两端的O(1)访问
3.1 队列的链式存储结构
定义两个结构体
- QNode:保存队列中节点的元素数据和下一个节点
- Queue:保存头指针、尾指针和队列中有效元素个数
typedef int QDateType;
typedef struct QueueNode
{
QDateType val;//当前节点的数据
struct QueueNode* next;//当前节点的下一个节点
}QNode;
typedef struct Queue
{
QNode* phead;//头指针
QNode* ptail;//尾指针
int size;//记录队列有效元素个数
}Queue;
3.2 队列的常见接口
//初始化
void QueueInit(Queue* pq);
//销毁
void QueueDestroy(Queue* pq);
//入队列
void QueuePush(Queue* pq,QDateType x);
//出队列
void QueuePop(Queue* pq);
//获取队头元素
QDateType QueueFront(Queue* pq);
//获取队尾元素
QDateType QueueBack(Queue* pq);
//判空
bool QueueEmpty(Queue* pq);
//获取有效元素个数
int QueueSize(Queue* pq);
3.3 队列的接口实现
初始化
头尾指针置空,队列有效元素个数初始化为0
void QueueInit(Queue* pq)
{
assert(pq);
//哨兵位可选可不选(可以有也可以没有)
pq->phead = pq->ptail = NULL;
pq->size = 0;
}
判空
直接返回Queue结构体保存的size即可
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->size == 0;
}
入队列
队尾入队步骤
(1)申请新节点并初始化该节点(将x赋值,下一个节点置空)
(2)判断是否存在尾节点(队列是否为空)
- 存在尾节点(队列不为空):只需将新节点接到队尾,尾指针后移一位即可。
- 不存在尾节点(队列为空):改变队头和队尾的值即可
(3)队列有效节点个数加1
void QueuePush(Queue* pq, QDateType x)
{
assert(pq);
QNode* newnode = (QNode*)malloc(sizeof(QNode));//申请新节点
if (newnode == NULL)
{
perror("malloc fail");
return;
}
//对新节点初始化
newnode->val = x;
newnode->next = NULL;
//有尾节点(队列不为空)
if (pq->ptail)
{
pq->ptail->next = newnode;
pq->ptail = newnode;
}
else
{
//一个有效节点都没(队列为空)
pq->phead = pq->ptail = newnode;
}
pq->size++;
}
出队列
(1)判空(队列不为空才能出队)
(2)判断队列有效节点的个数
- 一个节点:释放该节点,将头尾指针置空
- 多个节点:定义临时QNode类型变量保存头节点的下一个节点,释放头节点,头节点更新为保存的节点
(3)队列有效节点个数减1
void QueuePop(Queue* pq)
{
assert(pq);
//三种情况:0个节点,1个节点,多个节点
//0个
assert(pq->phead);//暴力检查
//if (pq->phead == NULL) return;//温柔检查
//队列只有1个有效节点
if (pq->phead->next==NULL)
{
free(pq->phead);
pq->phead = pq->ptail = NULL;
}
else
{
//队列有多个有效节点
QNode* next = pq->phead->next;
free(pq->phead);
pq->phead = next;
}
pq->size--;
}
获取队头元素
断言判断是否存在头节点,如果存在直接返回头节点的值即可
QDateType QueueFront(Queue* pq)
{
assert(pq);
//这里只能暴力检查
assert(pq->phead);
return pq->phead->val;
}
获取队尾元素
断言判断是否存在尾节点,如果存在直接返回尾节点的值即可
QDateType QueueBack(Queue* pq)
{
assert(pq);
//这里只能暴力检查
assert(pq->ptail);
return pq->ptail->val;
}
获取节点个数
返回size即可
int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}
销毁
遍历删除(释放)所有节点,最后头尾指针悬空,size置0
void QueueDestroy(Queue* pq)
{
assert(pq);
QNode* cur = pq->phead;
while (cur)
{
QNode* next = cur->next;
free(cur);
cur = next;
}
pq->phead = pq->ptail = NULL;
pq->size = 0;
}
3.4 源代码
.h文件
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int QDateType;
typedef struct QueueNode
{
QDateType val;
struct QueueNode* next;
}QNode;
入队
为什么需要两个指针
//void QueuePush(QNode** head,QNode** ptail);
//
出队
//void QueuePop(QNode** head);
typedef struct Queue
{
QNode* phead;
QNode* ptail;
int size;
}Queue;
//初始化
void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
//入队列
void QueuePush(Queue* pq,QDateType x);
//出队列
void QueuePop(Queue* pq);
QDateType QueueFront(Queue* pq);
QDateType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);
.c文件
#include "Queue.h"
//初始化
void QueueInit(Queue* pq)
{
assert(pq);
//哨兵位可选可不选
pq->phead = pq->ptail = NULL;
pq->size = 0;
}
//销毁
void QueueDestroy(Queue* pq)
{
assert(pq);
QNode* cur = pq->phead;
while (cur)
{
QNode* next = cur->next;
free(cur);
cur = next;
}
pq->phead = pq->ptail = NULL;
pq->size = 0;
}
//入队列
void QueuePush(Queue* pq, QDateType x)
{
assert(pq);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
perror("malloc fail");
return;
}
newnode->val = x;
newnode->next = NULL;
//有尾节点
if (pq->ptail)
{
pq->ptail->next = newnode;
pq->ptail = newnode;
}
else
{
//一个有效节点都没
pq->phead = pq->ptail = newnode;
}
pq->size++;
}
//出队列
void QueuePop(Queue* pq)
{
assert(pq);
//三种情况:0个节点,1个节点,多个节点
//0个
assert(pq->phead);//暴力检查
//if (pq->phead == NULL) return;//温柔检查
//1个
if (pq->phead->next==NULL)
{
free(pq->phead);
pq->phead = pq->ptail = NULL;
}
else//多个
{
QNode* next = pq->phead->next;
free(pq->phead);
pq->phead = next;
}
pq->size--;
}
QDateType QueueFront(Queue* pq)
{
assert(pq);
//这里只能暴力检查
assert(pq->phead);
return pq->phead->val;
}
QDateType QueueBack(Queue* pq)
{
assert(pq);
//这里只能暴力检查
assert(pq->ptail);
return pq->ptail->val;
}
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->size == 0;
}
int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}
4、队列的顺序存储(循环队列)
虽然队列的一般实现使用链式存储,但是也有一些情况可以使用数组存储,比如循环队列。
具体可以查看这篇博客———循环队列OJ
END