1.4 数据结构之 队列

已于 2024-03-03 22:24:08 修改
阅读量191 收藏
点赞数
分类专栏： 编程之美 文章标签： 数据结构
于 2021-04-11 17:55:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangwangmoon_light/article/details/115600395
版权

编程总结

在刷题之前需要反复练习的编程技巧，尤其是手写各类数据结构实现，它们好比就是全真教的上乘武功

顺序为自右往左.
在这里插入图片描述
/-------------------------------------------分割线--------------------------------------/
队头统一叫： head.
队尾统一叫： tail.

一. 循环队列的实现

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

  1. 判断队列是否为空的条件：

在这里插入图片描述

/* 检查循环队列是否为空 */
bool myCircularQueueIsEmpty(MyCircularQueue *obj) 
{
	return (obj->head == obj->tail);
}

手法1：检查循环队列是否为空，只看 head == tail. 如下特殊情况下，检查队列为空，也是看 head == tail.
在这里插入图片描述

  1. 判断队列是否为满的条件：
    在这里插入图片描述
/* 检查循环队列是否已满 */
bool myCircularQueueIsFull(MyCircularQueue *obj) 
{
	return ((obj->tail + 1) % obj->MaxSize == obj->head);
}

通常判断队列是否满，直接判断
(obj->tail + 1) == obj->head 即可。

手法2：但是循环队列，队列一直进，最后head为0，tail+1指向队列最后一个元素时；obj->tail + 1== obj->MaxSize. 此时也是队列满.
所以需要以下条件来判断：
((obj->tail + 1) % obj->MaxSize == obj->head);

  1. 进队列的条件：
    在这里插入图片描述
    进队列，队尾动，队尾插入：
    obj->base[obj->tail] = value;
    如果tail到了队尾要处理下，循环队列到队首.
    obj->tail = (obj->tail + 1) % obj->MaxSize;
    在这里插入图片描述
/* 在循环队列中插入元素, 如果操作成功, 则返回true */
bool myCircularQueueEnQueue(MyCircularQueue *obj, int value) {
	// 插入之前首先判断队列是否满
	if (myCircularQueueIsFull(obj)) {
		return false;
	}
	obj->base[obj->tail] = value;
	obj->tail = (obj->tail + 1) % obj->MaxSize;

	return true;
}
  1. 出队列的条件：
    队列为空，直接返回0;
    队列非空，直接移动 Head++,队尾进，队头出.
    obj->head = (obj->head + 1) % obj->MaxSize;
    在这里插入图片描述
/* 从循环队列中删除元素。如果操作成功，则返回true */
bool myCircularQueueDeQueue(MyCircularQueue *obj) {
	// 删除之前先判断队列是否为空
	if (myCircularQueueIsEmpty(obj)) {
		return false;
	}
	obj->head = (obj->head + 1) % obj->MaxSize;

	return true;
}
  1. 获取队首尾元素：
    手法1：队尾元素为 obj->base[obj->tail - 1]. 但有个特殊情况：tail为0时，tail-1小于0. tail为0时，其队尾元素为队列的最后一个元素 obj->base[obj->Maxsize-1].
/*从队列中获取 Front 项。*/
int myCircularQueueFront(MyCircularQueue *obj) 
{
	if (myCircularQueueIsEmpty(obj)) {
		return -1;
	}

	return obj->base[obj->head];
}

/*从队列中获取最后一项。*/
int myCircularQueueTail(MyCircularQueue *obj) 
{
	if (myCircularQueueIsEmpty(obj)) {
		return -1;
	}
	int i = (obj->tail - 1 + obj->MaxSize) % obj->MaxSize; // obj->tail -1 可能为0

	return obj->base[i];
}
  1. 释放队列：
void myCircularQueueFree(MyCircularQueue *obj) {
	if (obj->base) {
		free(obj->base);
	}
	obj->base = NULL;     // 先释放指针，并赋值NULL
	obj->front = 0;
	obj->rear = 0;
	free(obj);
}

/----------------队列实现完整代码----------------/

typedef struct {
	int *base;     // 开始地址
	int head;
	int tail;
	int MaxSize;
} MyCircularQueue;

bool myCircularQueueIsEmpty(MyCircularQueue *obj);
bool myCircularQueueIsFull(MyCircularQueue *obj);

/** Initialize your data structure here. Set the size of the queue to be k. */
MyCircularQueue* myCircularQueueCreate(int k) {
	MyCircularQueue *obj = (MyCircularQueue *)malloc(sizeof(MyCircularQueue));

	obj->base = (int *)malloc((k + 1) * sizeof(int));
	if (obj->base == NULL) {
		return false;
	}
	obj->head = 0;
	obj->tail = 0;
	obj->MaxSize = k + 1;                        // 需要维护一个 size+1 的队列.

	return obj;
}

/** Insert an element into the circular queue. Return true if the operation is successful. 插入元素，成功返回true*/
bool myCircularQueueEnQueue(MyCircularQueue *obj, int value) {
	// 插入之前首先判断队列是否满
	if (myCircularQueueIsFull(obj)) {
		return false;
	}
	obj->base[obj->tail] = value;                // 先入队
	obj->tail = (obj->tail + 1) % obj->MaxSize;  // tail再移动，队尾元素为tail-1.

	return true;
}

/* Delete an element from the circular queue. Return true if the operation is successful. */
bool myCircularQueueDeQueue(MyCircularQueue *obj) {
	// 删除之前先判断队列是否为空
	if (myCircularQueueIsEmpty(obj)) {
		return false;
	}
	obj->head = (obj->head + 1) % obj->MaxSize;

	return true;
}

/* Get the front item from the queue. */
int myCircularQueueFront(MyCircularQueue *obj)
{
	if (myCircularQueueIsEmpty(obj)) {
		return -1;
	}

	return obj->base[obj->head];
}

/* Get the last item from the queue. */
int myCircularQueueTail(MyCircularQueue *obj)
{
	if (myCircularQueueIsEmpty(obj)) {
		return -1;
	}
	int i = (obj->tail - 1 + obj->MaxSize) % obj->MaxSize; // 队尾元素为 obj->base[obj->tail - 1].
														   // 但有个特殊情况：tail为0时，tail-1小于0.
														   // tail为0时，其队尾元素为队列的最后一个元素 obj->base[obj->Maxsize-1].
														   
	return obj->base[i];
}

/* Checks whether the circular queue is empty or not. */
bool myCircularQueueIsEmpty(MyCircularQueue *obj)
{
	return (obj->head == obj->tail);
}

/* Checks whether the circular queue is full or not. */
bool myCircularQueueIsFull(MyCircularQueue *obj)
{
	return ((obj->tail + 1) % obj->MaxSize == obj->head);
}

void myCircularQueueFree(MyCircularQueue *obj) {
	if (obj->base) {
		free(obj->base);
	}
	obj->base = NULL;     // 先释放指针，并赋值NULL
	obj->head = 0;
	obj->tail = 0;
	free(obj);
}

int main(void)
{
	MyCircularQueue *obj = myCircularQueueCreate(3);
	int val = 1;
	int index = 0;

	myCircularQueueEnQueue(obj, 1);
	myCircularQueueEnQueue(obj, 2);
	myCircularQueueEnQueue(obj, 3);
	myCircularQueueEnQueue(obj, 4);

	val = myCircularQueueRear(obj);
	myCircularQueueDeQueue(obj);
	myCircularQueueEnQueue(obj, 4);
	myCircularQueueDeQueue(obj);
	myCircularQueueEnQueue(obj, 24);
	myCircularQueueEnQueue(obj, 25);
	val = myCircularQueueRear(obj);
	myCircularQueueDeQueue(obj);
	myCircularQueueDeQueue(obj);
	myCircularQueueDeQueue(obj);
	return 0;
}

二. 队列的实现

#define MAX_NUN 10000
typedef struct {
    int tail;
    int head;
    int size;     // 计算队列元素个数
    int *base;
} RecentCounter;

bool QueueIsEmpty(RecentCounter *obj)
{
    return (obj->head == obj->tail);
}

bool QueueIsFull(RecentCounter *obj)
{
    return ((obj->tail + 1) == obj->head);
}

bool QueueEnQueue(RecentCounter *obj, int value) {
    if (QueueIsFull(obj)) {
        return false;
    }
    obj->base[obj->tail] = value;                // 先入队
    obj->tail = (obj->tail + 1);                 // tail再移动，队尾元素为tail-1.
    obj->size++;
    return true;
}

int QueueFront(RecentCounter *obj)
{
    if (QueueIsEmpty(obj)) {
        return -1;
    }
    return obj->base[obj->head];
}

int QueueTail(RecentCounter *obj)
{
    if (QueueIsEmpty(obj)) {
        return -1;
    }
    return obj->base[obj->tail - 1];
}

bool QueueDeQueue(RecentCounter *obj) 
{
    if (QueueIsEmpty(obj)) {
        return false;
    }
    obj->head = (obj->head + 1);
    obj->size--;
    return true;
}

RecentCounter *QueueCreate(void) 
{
    RecentCounter *obj = (RecentCounter *)malloc(sizeof(RecentCounter));
    obj->base = (int *)malloc(sizeof(int)*(MAX_NUN+1));
    obj->tail = 0;
    obj->head = 0;
    obj->size = 0;
    if (obj->base == NULL) {
        return NULL;
    }
    memset(obj->base, 0, sizeof(int)*(MAX_NUN+1));
    return obj;
}

void QueueFree(RecentCounter* obj) 
{
    free(obj->base);
    obj->base = NULL;
    free(obj);
    obj = NULL;
}

346. 数据流中的移动平均值

– 循环队列的应用
在这里插入图片描述

typedef struct {
	int *base;     // 开始地址
	int head;
	int tail;
	int len;       // 需要计算的len长度
	int MaxSize;   // 队列长度
} MovingAverage;

/*  Initialize your data structure here. */
MovingAverage *movingAverageCreate(int size) 
{
	MovingAverage *obj = (MovingAverage *)malloc(sizeof(MovingAverage));
	obj->base = (int *)malloc(sizeof(int)*(size+ 1));

	memset(obj->base, 0, sizeof(int)*(size+1));
	obj->head = 0;
	obj->tail = 0;
	obj->MaxSize = size + 1;
	obj->len = 0;

	return obj;
}

bool movingAverageEmpty(MovingAverage *obj)
{
	return (obj->head == obj->tail);
}

bool movingAverageFull(MovingAverage *obj)
{
	return (((obj->tail + 1) % obj->MaxSize) == obj->head);
}

// 进队列
bool movingAveragePush(MovingAverage *obj, int num)
{
	if (movingAverageFull(obj) == 1) {
		return false;
	}
	// 赋值元素进来
	obj->base[obj->tail] = num;
	obj->tail = (obj->tail + 1) % obj->MaxSize;
	obj->len++;

	return true;
}

// 出队列
bool movingAveragePop(MovingAverage *obj, int num)
{
	if (movingAverageEmpty(obj) == 1) {
		return false;
	}

	obj->head = (obj->head + 1) % obj->MaxSize;
	obj->len--;

	return true;
}


double movingAverageNext(MovingAverage *obj, int val) 
{
	double res;
	long   result = 0;

	// 利用循环队列来计算
	// 需要计算的 len 超过队列长度时，队头出队列 head前移.
	if (obj->len >= obj->MaxSize - 1) {
		movingAveragePop(obj, val);
	}
	movingAveragePush(obj, val);

	for (int i = 0; i < obj->len; i++) {
		result += obj->base[(obj->head + i) % obj->MaxSize];
	}
	res = (double) result / (double)obj->len; // 除法的处理

	return res;
}

void movingAverageFree(MovingAverage* obj) 
{
	if (obj->base) {
		free(obj->base);
	}
	obj->base = NULL;
	obj->head = 0;
	obj->tail = 0;
	obj->MaxSize = 0;
	obj->len = 0;

	free(obj);
	obj = NULL;

	return ;
}

933. 最近的请求次数

– 队列的应用
在这里插入图片描述

#define MAX_NUN 10000
typedef struct {
    int tail;
    int head;
    int size;     // 计算队列元素个数
    int *base;
} RecentCounter;

bool QueueIsEmpty(RecentCounter *obj)
{
    return (obj->head == obj->tail);
}

bool QueueIsFull(RecentCounter *obj)
{
    return ((obj->tail + 1) == obj->head);
}

bool QueueEnQueue(RecentCounter *obj, int value) {
    if (QueueIsFull(obj)) {
        return false;
    }
    obj->base[obj->tail] = value;                // 先入队
    obj->tail = (obj->tail + 1);                 // tail再移动，队尾元素为tail-1.
    obj->size++;

    return true;
}

int QueueFront(RecentCounter *obj)
{
    if (QueueIsEmpty(obj)) {
        return -1;
    }

    return obj->base[obj->head];
}

int QueueTail(RecentCounter *obj)
{
    if (QueueIsEmpty(obj)) {
        return -1;
    }

    return obj->base[obj->tail - 1];
}

bool QueueDeQueue(RecentCounter *obj) 
{
    if (QueueIsEmpty(obj)) {
        return false;
    }
    obj->head = (obj->head + 1);
    obj->size--;

    return true;
}

RecentCounter *recentCounterCreate(void) 
{
    RecentCounter *obj = (RecentCounter *)malloc(sizeof(RecentCounter));
    obj->base = (int *)malloc(sizeof(int)*(MAX_NUN+1));
    obj->tail = 0;
    obj->head = 0;
    obj->size = 0;
    if (obj->base == NULL) {
        return NULL;
    }
    memset(obj->base, 0, sizeof(int)*(MAX_NUN+1));

    return obj;
}

int recentCounterPing(RecentCounter *obj, int t) 
{
    int tailA = 0;
    int tailB = 0;
    int tmp = 0;
    int res = 0;

    // 队列满
    if (QueueIsFull(obj) == 1) {
        return false;
    }
    // 1. 元素先入队
    QueueEnQueue(obj, t);

    // 2. 取出队尾元素
    while (obj->base[obj->head] < (t - 3000)) { // 由于队列是单调递增的,所以一旦小于右值，后续也将小于该值，可以出队列.
        QueueDeQueue(obj);
    }
    res = obj->tail - obj->head;

    return res;
}

void recentCounterFree(RecentCounter* obj) 
{
    free(obj->base);
    obj->base = NULL;
    free(obj);
    obj = NULL;
}
wangwangmoon_light
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 队列学习总结
sumandavg的博客
11-10 1497
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。 队列前言1. 队列介绍1.1 什么是队列1.2 队列的性质1.3 队列的构成1.4 队列的框架代码（C++版）2. 队列的操作2.1 初始化队列2.1.1 步骤2.1.2 代码展示2.2 入队操作2.2.1 步骤2.2.2 代码展示2.3 输出队列中的元素2.3.1 步骤2.3.2 代码展示2.4 出队操作2.4.1 步骤2.4.2 代码展示2..
数据结构实现（C++版）
11-28
1.基本数据结构 1.1.Array ........... 动态数组 1.2.LinkedList ... 链表 1.3.BST .............. 二分搜索树 1.4.MapBST ..... 二分搜索树（用于实现映射） 1.5.AVLTree ...... AVL树 2.接口 2.1.Queue .............
java数据结构 队列_Java数据结构与算法[原创]——队列
weixin_33855578的博客
02-12 89
声明：码字不易，转载请注明出处，欢迎文章下方讨论交流。前言：Java数据结构与算法专题会不定时更新，欢迎各位读者监督。本文介绍数据结构中的队列(queue)的概念、存储结构、队列的特点，文末给出java实现循环队列的代码实现供读者参考学习。1.队列的概念队列正如其名，队列就像一支队伍，有队首(head)和队尾(tail)以及队列长度。队列和栈类似，也是一个遵循特殊规则约束的数据结构。在上一篇文章j...
力扣 933. 最近的请求次数 C++队列问题
ganlanA的博客
10-09 441
写一个 RecentCounter 类来计算特定时间范围内最近的请求。 请你实现 RecentCounter 类： RecentCounter() 初始化计数器，请求数为 0 。 int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。 保证每次对 ping 的调用都使用比之前更大的 t 值。 示例 1： 输入： [“RecentCounter”,
队列当前元素个数计算
12november的博客
05-22 4964
（rear+maxSize-front）%MaxSize
C语言入门基础_初识常量变量
qq_19319481的博客
05-07 186
c语言常量与变量-字面常量/const修饰的常变量/#define 定义的标识符常量/枚举常量&全局变量/局部变量/作用域/生命周期
【数据结构】复习笔记
Coding Log
06-06 8300
第一章 概  论1.数据：信息的载体,能被计算机识别、存储和加工处理。2.数据元素：数据的基本单位，可由若干个数据项组成，数据项是具有独立含义的最小标识单位。3.数据结构：数据之间的相互关系，即数据的组织形式。它包括：1）数据的逻辑结构，从逻辑关系上描述数据，与数据存储无关，独立于计算机；2）数据的存储结构，是逻辑结构用计算机语言的实现，依赖于计算机语言。3）数据的运算，定义在逻辑结构上，每种逻辑
c语言数据结构之队列
Qurry的博客
09-25 1327
不同于栈，队列是一个先进先出的数据结构，规定数据节点从队列尾插入，从队列头取出，禁止对头尾两端以外的数据进行操作。队列可以分为顺序队列和循环队列。
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构实验1.4：带表头结点单链表的非递减排序.doc
10-29
【数据结构实验1.4：带表头结点单链表的非递减排序】 在数据结构的学习中，实验报告是验证理论知识并提升实践能力的重要环节。本实验报告的主题聚焦于带表头结点的单链表实现非递减排序，即对链表中的元素进行从小...
2005-数据结构与算法-期末答案1
08-03
这部分没有提供具体题目，但常见的选择题会涉及各种数据结构（如链表、栈、队列、树、图等）和算法（如排序、查找、递归等）的选择。 三、判断正误题： 这部分主要测试对基本概念的理解，如时间复杂度分析、数据...
大一下数据结构期末复习题综合题库
最新发布
07-03
绪论：1.2数据结构的基本概念与术语 1.4算法和算法分析 2. 线性表：2.1线性表的特点 2.3线性表的类型定义 2.4线性表的顺序表示和实现 2.5线性表的链式表示和实现 2.6循序表和链表的比较 2.7线性表的作用 3. 栈和...
1. 分享记录
凡物加倍磨治，皆能变化气质
11-12 1672
B树、B-树、B+树、B*树之间的关系 在对n个元素进行快排的过程中，最坏情况需要进行 n-1 轮。 快速排序的基本思想是分治。 快排是不稳定的，关键在于划分过程。现有的几种划分过程，基本都是分两个指针从左右同时扫描，然后交换元素，交换过程很容易打乱元素位置。 元素比较次数，也就是其复杂性分析。理想情况下，快速排序每次划分都将原始序列划分为两个等长的子序列。所以其比较次数为T(n)=2T(n/2)+n，所以其平均期望时间为nlog(n)。但在最坏情况下，即序列有序情形下，每次划分只能分出一个元素，因..
1.8 数据结构之 DFS
凡物加倍磨治，皆能变化气质
08-08 787
编程总结 本篇参考LeetCode学习 https://leetcode-cn.com/leetbook/read/dfs/euapvg/ 树的深度优先遍历 二叉树的深度优先遍历从「根结点」开始，依次 「递归地」 遍历「左子树」的所有结点和「右子树」的所有结点 1. 前序遍历 对于任意一棵子树，先输出根结点，再递归输出左子树的 所有 结点、最后递归输出右子树的 所有 结点。上图前序遍历的结果就是深度优先遍历的结果：[0、1、3、4、7、2、5、8、9、6、10]。 2. 中序遍历 对于任意一棵子树，先
1.5 数据结构之 栈
凡物加倍磨治，皆能变化气质
05-05 641
编程总结 在刷题之前需要反复练习的编程技巧，尤其是手写各类数据结构实现，它们好比就是全真教的上乘武功 栈是限制插入和删除只能在一个位置上进行的线性表。其中，允许插入和删除的一端位于表的末端，叫做栈顶（top），不允许插入和删除的另一端叫做栈底（bottom）。对栈的基本操作有 PUSH（压栈）和 POP （出栈），前者相当于表的插入操作（向栈顶插入一个元素），后者则是删除操作（删除一个栈顶元素）。栈是一种后进先出（LIFO）的数据结构，最先被删除的是最近压栈的元素。栈就像是一个箱子，往里面放入一个小盒
2.1 算法之 动态规划
凡物加倍磨治，皆能变化气质
10-07 577
编程总结 在刷题之前需要反复练习的编程技巧，尤其是手写各类数据结构实现，它们好比就是全真教的上乘武功 解决动态规划问题的核心：找出子问题及其子问题与原问题的关系 找到了子问题以及子问题与原问题的关系，就可以递归地求解子问题了。但重叠的子问题使得直接递归会有很多重复计算，于是就想到记忆化递归法：若能事先确定子问题的范围就可以建表存储子问题的答案。 动态规划算法中关于最优子结构和重复子问题的理解的关键点： 证明问题的方案中包含一种选择，选择之后留下一个或多个子问题 设计子问题的递归描述方式 证明对原问
1.7 数据结构之 BFS
凡物加倍磨治，皆能变化气质
04-18 565
编程总结 在刷题之前需要反复练习的编程技巧，尤其是手写各类数据结构实现，它们好比就是全真教的上乘武功。 本学习来自 leetcode，整理提炼. https://leetcode-cn.com/leetbook/read/queue-stack/kyozi/ 广度优先搜索（BFS）是一种遍历或搜索数据结构（如树或图）的算法。 如前所述，我们可以使用 BFS 在树中执行层序遍历。 我们也可以使用 BFS 遍历图。例如，我们可以使用 BFS 找到从起始结点到目标结点的路径，特别是最短路径。 我们可以在
0.0 常用函数库_字符串处理及快排
凡物加倍磨治，皆能变化气质
07-01 543
编程总结 每每刷完一道题后，其思想和精妙之处没有地方记录，本篇博客用以记录刷题过程中的遇到的算法和技巧 qsort 手法1：qsort可以用来排序结构体，如以下代码： typedef struct student { int height; int weight; int id; } student_t; int cmp(const void *a, const void *b) { student_t *aa = (student_t *)a; student
0.1 测试函数总结
凡物加倍磨治，皆能变化气质
02-16 403
记录测试代码 int main() { int *returnSize = NULL; int **returnColumnSizes = NULL; struct TreeNode *root = NULL; struct TreeNode *left = NULL; struct TreeNode *right = NULL; struct TreeNode *righ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值