一.队列
1.队列的概念及结构
队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出FIFO(First in first out)的特性
入队列:进行插入操作的一端称为队尾
出队列:进行删除操作的一端称为队头
2.队列的实现
队列也可以用数组和链表的结构实现,使用链表的结构实现更优一些,因为如果使用数组的结构,在数组头部出队列,效率会很低。
- 如果队列使用顺序表的结构实现,进行出队操作时,有两种方法,1是将对头指针指向下一个位置,这会造成空间上的浪费。
2是将对头后的所有数据向前移动一个位置,出队操作的时间复杂度就会变大,所以使用顺序表实现队列是不可取的。 - 因为队列要对对头和队尾进行操作,所以我们需要使用两个结构体指针,分别指向队头和队尾。
Queue.h
存放队列的所有函数的声明
#pragma once
#include<stdio.h>
#include<assert.h>
typedef int QDataType;
typedef struct QListNode
{
struct QListNode* next;
QDataType data;
}QNode;
typedef struct Queue
{
QNode* front;
QNode* tail;
int size;
}Queue;
void QueueInit(Queue* q);//初始化队列
void QueuePush(Queue* q, QDataType x);//队尾入队列
void QueuePop(Queue* q);//对头出队列
QDataType QueueFront(Queue* q);//获取队列头部元素
QDataType QueueTail(Queue* q);//获取队队尾元素
int QueueSize(Queue* q);//查看队列中有效元素的个数
int QueueEmpty(Queue* q);//查看队列是否为空,若是非空返回非零结果,若是为空,返回0
void QueueDestroy(Queue* q);//销毁队列
void QueuePrint(Queue* p);//打印队列
Queue.c
存放所有函数的实现
1.初始化队列
//初始化队列
void QueueInit(Queue* q)
{
q->front = NULL;
q->tail = NULL;
q->size = 0;
}
将对头和队尾全部置为空,当进行入队操作时,在使这两个指针分别指向对应的空间。
2.队尾入队列
//队尾入队列
void QueuePush(Queue* q, QDataType x)
{
assert(q);
QNode* newNode = (QNode*)malloc(sizeof(QNode));
if (!newNode)
{
perror("malloc fail");
exit(-1);
}
newNode->data = x;
newNode->next = NULL;
if (!q->front)
{
q->front = q->tail = newNode;
}
else
{
q->tail->next = newNode;
q->tail = newNode;
}
q->size++;
}
向内存申请一个存放数据的空间,并向其存放数据。
判断此时队列中是否有数据,如果没有,对头和队尾都指向申请的空间,如果有,将队尾指向的空间的next赋值为新申请的空间,在将队尾指向新申请的空间。
最后将队列的大小加1,完成入队操作
3.队头出队列
//对头出队列
void QueuePop(Queue* q)
{
assert(q);
//当队列中没有元素时
assert(q->front);
if (q->front == q->tail)
{
q->front = q->tail = NULL;
}
else
{
QNode* newNode = q->front;
q->front = q->front->next;
free(newNode);
}
q->size--;
}
首先判断,队列是否为空,若为空,无法进行出队列操作。
其次判断队列是否只要一个数据,若对头和队尾只写同一个空间,即只有一个数据,此时将两个指针都置为空,完成出队列操作。
如果,队列不为空,且队列中有多个数据,则队头进行操作,将对头指向的下一个位置变为对头,将之前的位置释放(队列中的空间是向内存申请的,需要释放,否则会造成内存泄漏),完成出队操作。
4.获取对头数据
//获取队列头部元素
QDataType QueueFront(Queue* q)
{
assert(q);//查看队列是否为空
assert(q->front);//查看队列头部是否为空
return q->front->data;
}
当队列不为空时,返回对头指向的空间所存储的数据即可。
5.获取队尾数据
//获取队队尾元素
QDataType QueueTail(Queue* q)
{
assert(q);
assert(q->front);
return q->tail->data;
}
若队列不为空,返回队尾指针指向的空间所存储的数据。
6.查看队列中有效元素的个数
//查看队列中有效元素的个数
int QueueSize(Queue* q)
{
assert(q);
assert(q->front);
//QNode* cur = q->front;
//int size = 0;
//while (cur)
//{
// size++;
// cur = cur->next;
//}
//return size;
return q->size;
}
有两种方法,
方法1:我们在设置队列的结构体时,定义了队列的长度size,此时返回size的大小即可。
方法2:若没有定义,则需要我们遍历队列,判断队列的长度
在实际应用队列时,我们不知道队列的结构体是如何设置的,我们只能通过这个函数来获取队列的有效元素的个数。
7.查看队列是否为空
//查看队列是否为空,若是非空返回非零结果,若是为空,返回0
int QueueEmpty(Queue* q)
{
assert(q);
return q->front == NULL && q->tail == NULL;
}
8.销毁队列
//销毁队列
void QueueDestroy(Queue* q)
{
assert(q);
QNode* cur = q->front;
while (cur)
{
QNode* temp = cur;
cur = cur->next;
free(temp);
}
q->front = q->tail = NULL;
q->size = 0;
}
队列中的空间都是向内存申请的,需要自己主动去释放,将队头的地址赋给一个临时的指针,由该指针去释放,当该指针为空时,表示已释放完毕。
最后我们将对头和队尾置空,将队列的大小改为0即可。
9.Queue.c完整代码
#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"
//初始化队列
void QueueInit(Queue* q)
{
q->front = NULL;
q->tail = NULL;
q->size = 0;
}
//队尾入队列
void QueuePush(Queue* q, QDataType x)
{
assert(q);
QNode* newNode = (QNode*)malloc(sizeof(QNode));
if (!newNode)
{
perror("malloc fail");
exit(-1);
}
newNode->data = x;
newNode->next = NULL;
if (!q->front)
{
q->front = q->tail = newNode;
}
else
{
q->tail->next = newNode;
q->tail = newNode;
}
q->size++;
}
//对头出队列
void QueuePop(Queue* q)
{
assert(q);
//当队列中没有元素时
assert(q->front);
if (q->front == q->tail)
{
q->front = q->tail = NULL;
}
else
{
QNode* newNode = q->front;
q->front = q->front->next;
free(newNode);
}
q->size--;
}
//获取队列头部元素
QDataType QueueFront(Queue* q)
{
assert(q);//查看队列是否为空
assert(q->front);//查看队列头部是否为空
return q->front->data;
}
//获取队队尾元素
QDataType QueueTail(Queue* q)
{
assert(q);
assert(q->front);
return q->tail->data;
}
//查看队列中有效元素的个数
int QueueSize(Queue* q)
{
assert(q);
assert(q->front);
//QNode* cur = q->front;
//int size = 0;
//while (cur)
//{
// size++;
// cur = cur->next;
//}
//return size;
return q->size;
}
//查看队列是否为空,若是非空返回非零结果,若是为空,返回0
int QueueEmpty(Queue* q)
{
assert(q);
return q->front == NULL && q->tail == NULL;
}
//销毁队列
void QueueDestroy(Queue* q)
{
assert(q);
QNode* cur = q->front;
while (cur)
{
QNode* temp = cur;
cur = cur->next;
free(temp);
}
q->front = q->tail = NULL;
q->size = 0;
}
//打印队列
void QueuePrint(Queue* p)
{
assert(p);
QNode* cur = p->front;
while (cur)
{
printf("%d ", cur->data);
cur = cur->next;
}
printf("\n");
}
二.循环队列
实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模式时可以使用循环队列。
循环队列可以使用数组实现,也可以使用循环链表实现。
这里我们使用数组实现,因为一般循环队列的长度是固定的,数组可以很好的契合这一标准。
1.循环队列的实现
环形队列可以用数组实现,也可以用循环链表实现。
根据不同的情况,我们选择不同的实现方法:
当给定的循环链表的大小是固定时,使用数组更为简单,可以少掉链表的插入和删除,直接根据下标解决问题。
当给定的循环链表的大小不是固定时,可以试着使用循环链表,也可以少掉很多麻烦。
- 这里我们根据Leetcode上的一道循环链表题来讲解这个知识点。
2.设计循环队列
设计循环队列
设计你的循环队列实现。 循环队列是一种线性数据结构,其操作表现基于 FIFO(先进先出)原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里,一旦一个队列满了,我们就不能插入下一个元素,即使在队列前面仍有空间。但是使用循环队列,我们能使用这些空间去存储新的值。
你的实现应该支持如下操作:
- MyCircularQueue(k): 构造器,设置队列长度为 k 。
- Front: 从队首获取元素。如果队列为空,返回 -1 。
- Rear: 获取队尾元素。如果队列为空,返回 -1 。
- enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
- deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
- isEmpty(): 检查循环队列是否为空。
- isFull(): 检查循环队列是否已满。
解题思路
该题中,循环队列给定了固定的大小,我们就可以使用顺序表实现它。
首先给出的数组大小为7个整形:
当队列为空时,我们将对头和队尾都指向下标为0的位置,
当插入元素时,我们将对头和队尾移动到下标为1~7的位置
这题的难点就是对队列入队和出队的操作,解决这两个问题,其他的在这两个的基础上也就迎刃而解。
这时我们就要分情况讨论了,
- 当队列已满时,有这几种情况
所以当我们判断队列是否已满,或进行入队操作时,可以根据这两种情况判断 - 当进行出队操作时,又有这两种特殊种情况
情况1:出队后队尾的位置加1等于对头的位置,表明此时队列为空,将对头和队尾置为0,表示此时队列为空
情况2:出队后对头的位置大于所给出队列的大小,需将队头位置改为1
其他出队情况直接将对头位置加1即可
代码
typedef struct {
int* arr;
int head;
int rear;
int size;
} MyCircularQueue;
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
if(!obj)
{
perror("malloc fail!");
exit(-1);
}
obj->arr = (int*)malloc(sizeof(int)*(k+1));
obj->head = obj->rear = 0;
obj->size = k;
return obj;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
assert(obj);
if(obj->head == 0)
{
obj->arr[++obj->head] = value;
obj->rear++;
return true;
}
else if(obj->rear < obj->size && (obj->rear+1 < obj->head || obj->rear >= obj->head))
{
obj->arr[++obj->rear] = value;
return true;
}
else if(obj->rear == obj->size && obj->head > 1)
{
obj->arr[1] = value;
obj->rear = 1;
return true;
}
return false;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
assert(obj);
if(obj->head)
{
obj->head++;
if(obj->head == obj->rear+1)
obj->head = obj->rear = 0;
else if(obj->head > obj->size)
obj->head = 1;
return true;
}
return false;
}
int myCircularQueueFront(MyCircularQueue* obj) {
assert(obj);
if(!myCircularQueueIsEmpty(obj))
return obj->arr[obj->head];
return -1;
}
int myCircularQueueRear(MyCircularQueue* obj) {
assert(obj);
if(!myCircularQueueIsEmpty(obj))
return obj->arr[obj->rear];
return -1;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
assert(obj);
if(obj->head == 0)
return true;
return false;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
assert(obj);
if(obj->rear+1 == obj->head)
return true;
if(obj->rear == obj->size && obj->head == 1)
return true;
return false;
}
void myCircularQueueFree(MyCircularQueue* obj) {
assert(obj);
free(obj->arr);
obj->arr = NULL;
obj->head = obj->rear = obj->size = 0;
}
/**
* 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);
*/