队列的模拟实现（单链链表模拟）

最新推荐文章于 2024-05-16 01:19:50 发布
最新推荐文章于 2024-05-16 01:19:50 发布
阅读量537 收藏
点赞数 2
分类专栏： C语言 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58724706/article/details/121103914
版权

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出，后进后出特特点。

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 。

出队列：进行删除操作的一端称为队头。

目录

队列的结构体创建 

队列的函数接口

void QueueInit(Queue* q)

void QueuePush(Queue* q, QDataType x)

void QueuePop(Queue* q)

QDataType QueueTail(Queue* q)

QDataType QueueHead(Queue* q)

int QueueSize(Queue* q)

void QueueDestroy(Queue* q)

bool QueueEmpty(Queue* q)

模拟队列的完整代码

Queue.c

Queue.c

测试代码test.c

队列的结构体创建 

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

typedef int QDataType;
typedef struct QueueNode //就这个结构体用来存放一个结点
{
    struct QueueNode* next; //定义一个指针，存放指向下一个结点的地址
    QDataType data;//存放当前结点的一个数据
}QNode;
typedef struct Queue //创建一个结构体，存放头结点和尾结点
{
    QNode* head; //头结点
    QNode* tail; //尾结点
}Queue;

这样的好处是，在后来定义变量时：Queue q;传参时可以传&q，接收时用一级指针就可以操作，因为在这里一级指针足够可以改变结构体里面的结点。

队列的函数接口

//队列初始化
void QueueInit(Queue* q);
//插入数据
void QueuePush(Queue* q, QDataType x);
//删除数据
void QueuePop(Queue* q);
//取队尾数据
QDataType QueueTail(Queue* q);
//取队头数据
QDataType QueueHead(Queue* q);
//记录队列中数据的个数
int QueueSize(Queue* q);
//销毁队列
void QueueDestroy(Queue* q);
//判断队列里是否有数据
bool QueueEmpty(Queue* q);

void QueueInit(Queue* q)

void QueueInit(Queue* q)
{
	assert(q);
	q->head = NULL;
	q->tail = NULL;
}

对Queue里面的两个结点进行初始化

void QueueInit(Queue* q)
{
    assert(q);//判断q是否为有效地址
    q->head = NULL; //头结点置空，避免被当成野指针乱用
    q->tail = NULL;//尾结点置空，避免被当成野指针乱用
}

void QueuePush(Queue* q, QDataType x)

void QueuePush(Queue* q, QDataType x)
{
	assert(q);
	//开辟一个结点
	QNode* tmp = (QNode*)malloc(sizeof(QNode));
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	tmp->data = x;
	tmp->next = NULL;
	if (QueueEmpty(q))
	{
		q->head = q->tail = tmp;
	}
	else
	{
		q->tail->next = tmp;
		q->tail = tmp;
	}
}

在队尾插入数据

void QueuePush(Queue* q, QDataType x)
{
    assert(q);

     //插入数据后需要申请一块空间，来作为结点
    QNode* tmp = (QNode*)malloc(sizeof(QNode));    //开辟一个结点
    if (tmp == NULL) //判断结点是否开辟成功
    {
        printf("malloc fail\n");
        exit(-1);
    }
    tmp->data = x; //结点存放一个数据
    tmp->next = NULL;//结点指向下一个地址为空，避免被当成野指针乱用
    if (QueueEmpty(q)) //如果队列中为空时
    {
        q->head = q->tail = tmp; //头结点和尾结点都指向第一个新新结点
    }

    //如果不判断的话，头结点一直是指向NULL的，在插入第一个结点时，tail是空结点，不          能指向下一个结点
    else //当头结点不为空时
    {
        q->tail->next = tmp;//尾结点指向新结点结点
        q->tail = tmp; //尾结点的地址变成新结点的地址
    }
}

void QueuePop(Queue* q)

void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	QNode* next = q->head->next;
	free(q->head);
	q->head = next;
	if (q->head == NULL)
	{
		q->tail = NULL;
	}
}

删除队列中头结点的数据

void QueuePop(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));//判断队列是否为空，不为空的话，就继续
    QNode* next = q->head->next; //提前记录好第一个结点的下一个结点的位置
    free(q->head);//释放第一个结点的空间
    q->head = next;//头结点地址变成next,即原链表第二个结点的地址，这样就删除了头结点     了，在这里不用分情况，即使next为NULL，pop后head和tail都为NULL了,相当于队列中没     有节点了

    if (q->head == NULL)//如果头结点为空了（不断头删），说明没有数据了，尾结点指向的      空间被释放了，但是尾结点还记录原来的地址，这时候尾结点变成野指针了
    {
        q->tail = NULL;//这时候尾结点要置空
    }

如果么有这个if语句，如图：


}

 

QDataType QueueTail(Queue* q)

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

返回队尾的数据

QDataType QueueTail(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));
    return q->tail->data; //q指向队尾的结点的数据
}

QDataType QueueHead(Queue* q)

QDataType QueueHead(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->head->data;
}

返回队头的数据

QDataType QueueHead(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));
    return q->head->data;//q指向队头的结点的数据
}

int QueueSize(Queue* q)

int QueueSize(Queue* q)
{
	assert(q);
	QNode* cur = q->head;
	int size = 0;
	while (cur)
	{
		cur = cur->next;
		size++;
	}
	return size;
}

记录队列中结点的个数

int QueueSize(Queue* q)
{
    assert(q);
    QNode* cur = q->head;//cur记录头结点，在遍历的过程中，cur在改变，而头结点就不会                                               被误改了
    int size = 0; //记录结点个数
    while (cur) //当cur为空时就结束循环，这时候，队列中不为空的结点都已经被遍历一遍了
    {
        cur = cur->next; //cur不断指向下一个
        size++; //每次经过一个结点，个数加1
    }
    return size;//返回结点个数
}

void QueueDestroy(Queue* q)

void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//空间释放完之后，头结点和尾结点还记着原来的地址，在这里需要置空
	q->tail = q->head = NULL;
}

对在堆区上开辟的队列空间的销毁

void QueueDestroy(Queue* q)
{
    assert(q);
    QNode* cur = q->head; //cur记录头结点，用来遍历结点
    while (cur)//当cur为空时就结束循环，这时候，队列中不为空的结点都已经被遍历一遍了
    {
        QNode* next = cur->next; //next提前记录下一个结点，防止当前结点销毁后，下一个结                                                     点的地址就找不到了
        free(cur);//释放当前结点
        cur = next;//cur变成提前记录好的next
    }
    //空间释放完之后，头结点和尾结点还记着原来的地址，在这里需要置空
    q->tail = q->head = NULL;
}

bool QueueEmpty(Queue* q)

bool QueueEmpty(Queue* q)
{
	assert(q);
	return  q->head==NULL;
}

判断队列中是否为空

bool QueueEmpty(Queue* q)
{
    assert(q);
    return  q->head==NULL; //如果头结点为空就返回真（true），否则返回假（false）

    //因为头结点指向空时意味着，尾结点也指向空，这时候队列就为空了
}

模拟队列的完整代码

Queue.c

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

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

//队列初始化
void QueueInit(Queue* q);
//插入数据
void QueuePush(Queue* q, QDataType x);
//删除数据
void QueuePop(Queue* q);
//取队尾数据
QDataType QueueTail(Queue* q);
//取队头数据
QDataType QueueHead(Queue* q);
//记录队列中数据的个数
int QueueSize(Queue* q);
//销毁队列
void QueueDestroy(Queue* q);
//判断队列里是否有数据
bool QueueEmpty(Queue* q);

Queue.c

#define  _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"

void QueueInit(Queue* q)
{
	assert(q);
	q->head = NULL;
	q->tail = NULL;
}

void QueuePush(Queue* q, QDataType x)
{
	assert(q);
	//开辟一个结点
	QNode* tmp = (QNode*)malloc(sizeof(QNode));
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	tmp->data = x;
	tmp->next = NULL;
	if (QueueEmpty(q))
	{
		q->head = q->tail = tmp;
	}
	else
	{
		q->tail->next = tmp;
		q->tail = tmp;
	}
}

void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	QNode* next = q->head->next;
	free(q->head);
	q->head = next;
	if (q->head == NULL)
	{
		q->tail = NULL;
	}
}

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

QDataType QueueHead(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->head->data;
}

int QueueSize(Queue* q)
{
	assert(q);
	QNode* cur = q->head;
	int size = 0;
	while (cur)
	{
		cur = cur->next;
		size++;
	}
	return size;
}

void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//空间释放完之后，头结点和尾结点还记着原来的地址，在这里需要置空
	q->tail = q->head = NULL;
}

bool QueueEmpty(Queue* q)
{
	assert(q);
	return  q->head==NULL;
}

测试代码test.c

#define  _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"

void QueueTest1()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);

	QDataType tmp = QueueHead(&q);
	printf("%d\n", tmp);

     tmp = QueueTail(&q);
	printf("%d\n", tmp);

	QueuePop(&q);
	tmp = QueueSize(&q);
	tmp = QueueHead(&q);
	printf("%d\n", tmp);

	QueuePush(&q, 4);
	QueuePush(&q, 4);
	QueuePop(&q);
	tmp = QueueSize(&q);
	printf("%d\n", tmp);

}
int main()
{
	QueueTest1();
	return 0;
}

测试结果：

暴走的橙子～
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】队列的模拟实现
m0_57248981的博客
03-24 470
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为。注意：Queue是个接口，在实例化时必须实例化LinkedList的对象，因为LinkedList实现了Queue接口。）是指允许两端都可以进行入队和出队操作的队列，出队列：进行删除操作的一端称为。1.环形队列通常使用数组实现。
单链表循环队列
Acceleration_的博客
04-28 4211
// // queue_.cpp // Cycle // // Created by ljpc on 2018/5/30. // Copyright © 2018年 ljpc. All rights reserved. // #include "queue_.h" void creatCycleQueue(CycleQueue* que) // 创建一个循环队列指针que { que->size_ = 0; que->rear = NULL; } bool is.
【软考笔记——软件设计师】(十二)数据结构与算法_循环单链表的入队和出队需要遍历吗(1)
最新发布
2401_84973739的博客
05-16 225
栈是一种先进后出（后进先出）的线性结构，只能在栈的一端（栈顶）进行插入和删除。递归的次数 × 每次递归的时间复杂度（适用于每次递归时间复杂度不变的情况）时间复杂度估算看最内层循环，如若没有循环和递归则为O（1）加法规则：多项相加，保留最高阶项，并将系数化为1。加法乘法混合规则：先小括号再乘法规则最后加法规则。字串是指由主串中任意长度连续的字符构成的序列。乘法规则：多项相乘都保留，并将系数化为1。ac不是字串，因为它不是主串中连续的字符。字符串是线性结构，空格也是字符串。字串：a、b、c、ab、bc。
【队列】模拟队列
nathanqian123的博客
01-05 515
模拟队列
单个指针下循环链表的入队与出队
makerjack001的博客
10-27 3686
循环链表的入队出队 题目是这样的： 设以不带头结点的循环链表表示队列，并且只设一个指针指向队尾结点，但不设头指针。编写相应的入队和出队程序。 如果带头尾指针那就很简单了，不带头尾指针只能在函数中新建工作指针来操作。 思考方向 队列嘛，先进先出，用循环链表存储，再有个尾指针，逻辑结构就是这样的 入队 入队分三步： 新结点指向头结点 尾结点指向新节点 尾指针指向新的尾结点 出队 先进先出嘛，头结点删了就行 理论上直接尾结点指向第二个就完事了 但这样只是找不到了原来的头结点，它依然是存在于内存中的，虽说眼不见为
队列的模拟实现
ahui_is_so_cool的博客
08-08 466
环形队列和普通队列的实现
java实现单链表、双向链表
09-02
Java中的链表是一种数据结构，它不依赖于内存中的连续空间来...这些基础数据结构在许多实际编程问题中都有应用，例如在实现LRU缓存策略、模拟队列和栈等高级数据结构时。理解并熟练掌握链表是提升编程技能的重要一步。
Java模拟有序链表数据结构的示例
09-02
例如，对于优先级队列的应用，其中频繁需要获取和处理最小元素，有序链表是一个很好的选择。然而，如果需要在链表中间插入或删除元素，其效率则不如平衡二叉搜索树等其他数据结构。 总之，这个Java示例展示了如何...
用链表实现队列（最终版）.zip
03-06
在计算机科学中，数据结构是组织和存储数据的方式，它对算法的设计和效率有直接影响。...此外，由于队列和链表都是抽象数据类型，它们可以应用于各种算法和程序设计问题，如模拟打印机任务、网络数据包处理等。
JS实现链表，前端必会
09-20
在前端开发中，理解并能实现链表可以帮助我们更好地处理动态数据集合，例如在实现某些高级数据结构（如堆栈、队列、哈希表）或算法（如快速排序、归并排序）时。 链表不同于数组，它不连续存储数据，而是通过节点...
使用python实现链表操作
09-20
5. 队列实现双向列表 在Python中，可以利用内置的`collections.deque`类来实现一个类似双向链表的功能。`deque`提供了高效的插入和删除操作，并且支持双向遍历。 总的来说，通过定义类和方法，我们可以用Python实现...
数组模拟队列
papillonlong的博客
01-10 88
1.队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear 所指的数组元素中，否则无法存入数据。3.当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤：思路分析。将尾指针往后移：rear+1 , 当 front == rear 【空】rear == maxSize - 1[队列满]
链式队列的基本操作（入队、出队、遍历队列、清空队列）
Kevinnsm的博客
03-30 9350
链式队列是一种特殊的链表，只能在尾部添加，在头部删除，类似于排队问题，先入先出 代码如下 #include<stdio.h> #include<malloc.h> #include<stdlib.h> #define ERROR 0 typedef int ElemType; typedef struct Queue{ struct Queue*next; ...
【数据结构与算法】队列-模拟实现队列以及设计循环队列
云泽野の编程日记
01-29 550
队列是先进先出的数据结构,不要和栈记混淆了.掌握链表实现栈,以及循环队列的原理熟悉循环队列中什么情况下队列满了 出队和入队时 front和rear 怎么进行调整。
队列模拟（queue）
mytzs123的博客
01-10 1026
可先了解链表相关知识：链表（单向链表的建立、删除、插入、打印） - 蓝海人 - 博客园 // queue.h -- interface for a queue #ifndef QUEUE_H_ #define QUEUE_H_ // This queue will contain Customer items class Customer { private: long arrive; // arrival time for customer 顾客的到达时间 int p
java 新建数组_Java 基础数据结构分析
weixin_39848953的博客
12-02 111
java -version java version "13.0.2" 2020-01-14 Java(TM) SE Runtime Environment (build 13.0.2+8) Java HotSpot(TM) 64-Bit Server VM (build 13.0.2+8, mixed mode, sharing)Array数组能够做到快速随机访问元素，这是因为当我们创建一个数组...
链式存储结构实现队列的入队和出队操作以及 栈的出栈和入栈操作
热门推荐
wtm
07-22 2万+
链式存储结构实现队列的入队和出队操作以及 栈的出栈和入栈操作其实本质上就是用含头结点的单链表来模拟队列的入队和出队，以及栈的入栈和出栈 换句话来形容，用单链表来实现队列和栈 对于队列： 存储结构 typedef struct QueueNode//队列结点 { int data; QueueNode *next; }QueueNode; typedef struct
java 使用链表来模拟队列的入队出队操作
baizhi4791的博客
01-22 525
队列：先进先出； 队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 1.节点类代码 public class Entry<T> { private T value; private Entry<T> ...
C/C++ 队列的出队入队单链表实现（完整代码）
SanpTap的博客
06-15 4776
队列的C/C++实现逻辑比较简单，用单链表实现队列的创建、入队、出队和判断队列是否为空操作，这里直接贴代码了。 /* 完整代码 */ #include <iostream> using namespace std; typedef struct queue { int val; struct queue* next; }Queue; void Init(...
《数据结构与算法分析》模拟试题及答案解析
在模拟试题中，线性结构的概念被提及，如队列和链表。线性结构的特点是元素之间存在一对一的关系，如题目中的单链表和队列。 2. **算法**：算法是解决问题的步骤或计算过程。试题中涉及到栈的操作，如入栈和出栈...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值