队列--C语言实现数据结构

已于 2023-07-30 23:42:55 修改
阅读量6.7k 收藏 3
点赞数 4
分类专栏： 数据结构 文章标签： c语言 数据结构 算法 学习
于 2023-07-15 01:30:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_76062618/article/details/131732273
版权

在这里插入图片描述

本期带大家一起用C语言实现队列🌈🌈🌈

文章目录

1、队列的概念

队列是一种线性数据结构，它按照先进先出（FIFO）的原则进行操作。可以把队列想象成排队买票或者排队上公交车的队伍。

顺序队列由一个连续的内存区域组成，可以存储多个元素。队列有两个指针，分别指向队头（Front）和队尾（Rear）。
链式队列由一系列节点构成，每个节点包含存储的元素值和指向下一个节点的指针
队列的基本操作包括：

  1. 入队（Enqueue）：将新元素插入到队尾，如果队列已满则无法插入。
  2. 出队（Dequeue）：移除队头元素，并返回该元素，如果队列为空则无法执行。
  3. 获取队头元素（Front）：获取队头元素的值，但不对队列进行修改。
  4. 判断队列是否为空（isEmpty）：判断队列中是否没有任何元素。
  5. 判断队列是否已满（isFull）：判断队列是否已经达到了最大容量。

队列的操作遵循先进先出的原则，即先入队的元素先出队。在队列中，新元素被插入到队列的末尾，而出队操作始终从队列的头部进行。

队列常用于需要顺序处理任务或数据的场景，例如处理请求、消息传递、广度优先搜索等算法实现。此外，队列还可以通过循环队列的方式来实现，使得已经出队的元素可以再次被插入到队列的末尾，有效地利用内存空间。

2、队列的操作流程

在这里插入图片描述

3 、队列的结构

队列通常使用数组或链表来实现。以下是两种常见的队列结构：

  1. 基于数组的队列（顺序队列）：

    • 使用一个固定大小的数组来保存队列元素。
    • 需要维护队头和队尾的索引，分别指向队列的第一个元素和最后一个元素。
    • 入队操作将元素添加到队尾，并更新队尾索引。
    • 出队操作将队头元素移除，并更新队头索引。
    • 注意，入队操作可能导致队列满（队尾索引达到数组末尾）的情况，需要进行特殊处理。

  2. 基于链表的队列（链式队列）：

    • 使用链表来动态存储队列元素。
    • 需要维护队头和队尾节点指针，分别指向队列的第一个节点和最后一个节点。
    • 入队操作创建一个新节点，并将其链接到链表末尾，更新队尾指针。
    • 出队操作移除队头节点，并更新队头指针。
    • 注意，链式队列没有固定的大小限制，可以根据需要动态调整。

无论是基于数组还是链表的队列，其核心思想都是维护队头和队尾指针，并通过头部和尾部的插入和删除操作实现先进先出的特性。根据具体的应用场景和需求，选择适合的队列实现方式

在这里我们使用链表来实现队列，避免了用数组队列更新队头数据的遍历，时间复杂度低

4、队列的实现

4.1 队列的结构设计

Queue结构体，它表示整个队列。该结构体包含两个指针成员head和tail，分别指向队列的头部节点和尾部节点
QNode的结构体，它表示队列中的节点。该结构体包含一个指向下一个节点的指针next，以及一个数据data

typedef int QDataTYpe;

typedef struct QueueNode
{
	struct QueueNode* next;

	QDataTYpe data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

4.2 队列的初始化

现在主函数当中创建了一个Queue q
然后传入q的地址，进行初始化
将队列的头部指针和尾部指针设为NULL，并将队列的大小初始化为0

void QueueInit(Queue* pq)
{
	pq->head = NULL;
	pq->tail = NULL;

	pq->size = 0;
}

4.3 入队

在函数内部，首先进行断言assert(pq)来确保指针pq不为空。

然后，通过动态内存分配malloc来创建一个新的节点newnode，并将其类型转换为QNode*。

接下来，检查是否成功分配内存，如果分配失败，则输出错误信息并返回。

然后，将新节点的数据成员data赋值为传入的参数x，同时将新节点的下一个指针next设置为NULL，新节点表示当前节点是队列的尾部节点。

接着，根据队列是否为空，有两种情况处理：

  • 如果队列为空，即头部指针head为NULL，表示当前队列没有任何节点，此时将头部指针和尾部指针都指向新节点newnode。
  • 如果队列不为空，即头部指针head不为NULL，表示当前队列已存在节点，此时将队列尾部节点的下一个指针next指向新节点newnode，然后将尾部指针tail更新为新节点newnode
  • 最后，将队列的大小size加1，表示新增了一个节点。
void QueuePush(Queue* pq,QDataTYpe x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));;

	if (newnode == NULL)
	{
		perror("malloc:fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;

		pq->tail = newnode;
	}
	pq->size++;

}

4.4 判断队列是否为空

判断队列是否为空的话，相对来说是比较简单的
有两种判断方法
根据队列的头指针是否为空判断
根据队列当中的数据个数size判断

bool QueueEmpty(Queue* pq)
{
	return pq->head == NULL;
	//return pq->size==0;
}

4.5 出队

出队列的话我们需要先判断当前队列是否为空
队列为空的话那我们就直接返回
队列不为空的话又分两种情况
1、队头指针==队尾指针

2、队头指针！=队尾指针

void QueuePop(Queue* pq)
{
	assert(pq);

	if (QueueEmpty(pq))
	{
		printf("队列为空\n");
		return;
	}

	if (pq->head == pq->tail)
	{
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;

	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}

4.6 获取队头数据

获取队头数据的话，需要先判断队列是否为空，为空的话就直接返回
队列不为空，返回队头数据

QDataTYpe QueueFront(Queue* pq)
{
	assert(pq);

	if (QueueEmpty(pq))
	{
		printf("队列为空\n");
		return;
	}

	else
		return pq->head->data;
}

4.7 获取队尾数据

获取队尾数据的话，同样需要判断队列是否为空，为空的话也就直接返回
队列不为空的话，返回队尾数据

QDataTYpe QueueBack(Queue* pq)
{
	assert(pq);

	if (QueueEmpty(pq))
	{
		printf("队列为空\n");
		return;
	}
	else
		return pq->tail->data;
}

4.8 获取队列当中数据的个数

获取队列数据的个数，直接返回pq->size

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

4.9 队列的销毁

使用循环遍历队列中的所有节点，直到遍历到最后一个节点，即当前节点为NULL


void QueueDestroy(Queue* pq)
{

	assert(pq);

	QNode* cur = pq->head;

	while (cur != NULL)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;

	}

	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;

}

5、栈和队列OJ题

5.1 队列模拟栈

在这里插入图片描述

使用两个队列来实现栈的重点在于以下几点：

  1. 始终保持一个队列为空，另一个队列非空。
  2. 入数据时，将元素入队到不为空的队列中。
  3. 出数据时，将非空队列中的元素转移到空队列中，直到队列中只剩下一个元素。
  4. 出队原先非空队列的数据，原先非空队列变为空，即可实现栈的后进先出操作。

通过将元素入队到非空队列、转移到空队列以及出队的操作，可以模拟栈的后进先出特性

在这里插入图片描述

typedef int QDataTYpe;

typedef struct QueueNode
{
	struct QueueNode* next;

	QDataTYpe data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;



void QueueInit(Queue* pq);


void QueueDestroy(Queue* pq);

void QueuePush(Queue* pq,QDataTYpe x);

void QueuePop(Queue* pq);

bool QueueEmpty(Queue* pq);

QDataTYpe QueueFront(Queue* pq);

QDataTYpe QueueBack(Queue* pq);

int QueueSize(Queue* pq);
void QueueInit(Queue* pq)
{
	pq->head = NULL;
	pq->tail = NULL;

	pq->size = 0;
}


void QueueDestroy(Queue* pq)
{

	assert(pq);

	QNode* cur = pq->head;

	while (cur != NULL)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;

	}

	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;

}


bool QueueEmpty(Queue* pq)
{
	return pq->head == NULL;
	//return pq->size==0;
}


void QueuePush(Queue* pq,QDataTYpe x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));;

	if (newnode == NULL)
	{
		perror("malloc:fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;

		pq->tail = newnode;
	}
	pq->size++;

}


void QueuePop(Queue* pq)
{
	assert(pq);

	if (QueueEmpty(pq))
	{
		printf("队列为空\n");
		return;
	}

	if (pq->head == pq->tail)
	{
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;

	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = NULL;
		pq->head = next;
	}
	pq->size--;
}




QDataTYpe QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

		return pq->head->data;
}

QDataTYpe QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
		return pq->tail->data;
}


int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}


typedef struct {
    Queue q;
    Queue p;
} MyStack;


MyStack* myStackCreate() {
    MyStack*obj=(MyStack*)malloc(sizeof(MyStack));
    if(obj==NULL)
    {
        return NULL;
    }
    QueueInit(&obj->p);
    QueueInit(&obj->q);
		return obj;
}

void myStackPush(MyStack* obj, int x) {

    if(QueueEmpty(&obj->p))
    {
        QueuePush(&obj->q,x);
    }
    else
    {
        QueuePush(&obj->p,x);
    }
}

int myStackPop(MyStack* obj) {
    Queue*Empty=&obj->q;
    Queue*NoEmpty=&obj->p;
    if(QueueEmpty(&obj->p))
    {
        Empty=&obj->p;
        NoEmpty=&obj->q;
    }

    while(QueueSize(NoEmpty)>1)
    {
        QueuePush(Empty,QueueFront(NoEmpty));

        QueuePop(NoEmpty);
    }

    int top=QueueFront(NoEmpty);
    QueuePop(NoEmpty);
    return top;
}

int myStackTop(MyStack* obj) {
    if(QueueEmpty(&obj->p))
    {
        return QueueBack(&obj->q);
    }
    else
    return QueueBack(&obj->p);
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q)&&QueueEmpty(&obj->p);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q);
    QueueDestroy(&obj->p);
    free(obj);
}

5.2 栈模拟队列

栈模拟队列
在这里插入图片描述
栈模拟队列的话，可以想象成一个连通器
在这里插入图片描述

在这里插入图片描述



typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;


//初始化
void STInit(ST* ps);

//销毁
void STDestroy(ST* ps);

//压栈

void STPush(ST* ps,STDataType x);


//出栈

void STPop(ST* ps);

//判空

bool STEmpty(ST* ps);

//栈顶

STDataType STTop(ST* ps);

//个数

int STSize(ST* ps);



void STInit(ST* ps)
{

	assert(ps);

	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;

}


void STDestroy(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;

	ps->top = 0;
}




void STPush(ST* ps,STDataType x)
{

	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;

		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity*sizeof(STDataType));

		if (tmp == NULL)
		{
			perror("realloc :fail");
			return;
		}

		ps->a = tmp;

		ps->capacity = newcapacity;

	}
	ps->a[ps->top++] = x;

}

bool STEmpty(ST* ps)
{

	return ps->top == 0;
}

void STPop(ST* ps)
{

	assert(ps);
	assert(!STEmpty(ps));

	ps->top--;
}


STDataType STTop(ST* ps)
{

	assert(ps);

	return ps->a[ps->top - 1];

}


int STSize(ST* ps)
{
	assert(ps);

	return  ps->top;

}



typedef struct {
    ST pushst;
    ST popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue*obj=(MyQueue*)malloc(sizeof(MyQueue));
    
    STInit(&obj->pushst);
    STInit(&obj->popst);
    return obj;
    
    
}

void myQueuePush(MyQueue* obj, int x) {
    STPush(&obj->pushst,x);

}

int myQueuePop(MyQueue* obj) {
    int ret=myQueuePeek(obj);
    STPop(&obj->popst);
    return ret;
   
}

int myQueuePeek(MyQueue* obj) {
     if(STEmpty(&obj->popst))
    {
        while(!(STEmpty(&obj->pushst)))
        {
            STPush(&obj->popst,STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }
    return STTop(&obj->popst);
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->pushst)&&STEmpty(&obj->popst);
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->pushst);
        STDestroy(&obj->popst);

    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

5.3 循环队列

循环队列
在这里插入图片描述
解决循环队列问题的话
我们可以先定义固定大小的数组，用来存储元素
例如，我们需要一个可以存储3个数据的数组，我们现在就开辟4个数据的空间，以便于我们操作在这里插入图片描述

在这里插入图片描述




typedef struct {
    int front;
    int rear;
    int size;
    int *a;
} MyCircularQueue;
bool myCircularQueueIsFull(MyCircularQueue* obj) ;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=(int*)malloc(sizeof(int)*(k+1));
    obj->size=k+1;
    obj->front=0;
    obj->rear=0;
    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
   if((obj->rear+1)%(obj->size)==obj->front)
   return false;
   obj->a[obj->rear]=value;
   obj->rear++;
   obj->rear%=obj->size;
   return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
     if(obj->rear==obj->front)
     return false;
     (obj->front)++;
     obj->front%=obj->size;
     return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(obj->rear==obj->front)
    return -1;
    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(obj->rear==obj->front)
    return -1;
    

    return obj->a[(obj->rear-1+obj->size)%obj->size];

}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    if(obj->rear==obj->front)
    return true;
    return false;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    if((obj->rear+1)%(obj->size)==obj->front)
    return true;
    return false;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    obj->a=NULL;
    free(obj);
}

/**
 * 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);
*/

6、感谢与交流✅

🌹🌹🌹如果大家通过本篇博客收获了,对队列有了新的了解的话
那么希望支持一下哦如果还有不明白的，疑惑的话，或者什么比较好的建议的话，可以发到评论区，
我们一起解决，共同进步 ❗️❗️❗️
最后谢谢大家❗️❗️❗️💯💯💯

在这里插入图片描述

一个大不遛
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C语言实现队列
11-13
C语言实现的队列，与list_node类型相似，可通用
一个通用纯C队列的实现
kxcfzyk的专栏
06-17 4784
队列并不是很复杂的数据结构，但是非常实用，这里实现一个队列是为了
【数据结构与算法】详解循环队列：基于数组实现高效存储与访问
最新发布
2302_78391795的博客
06-24 1401
循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。相比于传统的队列实现，循环队列能够更有效地利用存储空间，并在数组大小固定的情况下实现队列的无限循环。在本文中，我们将详细探讨如何使用数组来实现循环队列，并分析其优势和应用场景。
c实现队列
fzl_blog的博客
04-04 420
今天又应要求补充了很多注释，应该都没问题很容易能看懂，我还加了实现原理图，so easy,妈妈再也不用担心你的学习了！ok队列：先进先出，只能实现尾插，头删如下图：// main.c // 队列 // Created by fzl // Copyright © All rights reserved. #include <stdio.h> #include <stdlib.h> type
C语言队列的实现
我的博客
04-16 1554
系列文章目录 文章目录系列文章目录队列一、队列是什么？二、队列的实现1.定义数据类型2.队列的各种接口3.初始化队列4.销毁队列5.入队6.出队7.队列是否为空8.求队列长度9.获取队头数据10.获取队尾数据总结 队列 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、队列是什么？ 队列是一种特殊的线性表，特点是FIFO，适合用链式结构实
数据结构-循环队列-C语言实现循环队列-数据结构学习
05-27
C语言实现的数据结构中的循环队列 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件，以及测试用的main.c文件 用于C语言以及数据结构的学习 循环队列的.c和.h文件实现了以下功能： 创建循环队列 入队列...
C语言数据结构链表队列的实现
12-31
C语言数据结构链表队列的实现 1.写在前面 　队列是一种和栈相反的，遵循先进先出原则的线性表。 　本代码是严蔚敏教授的数据结构书上面的伪代码的C语言实现代码。 　分解代码没有包含在内的代码如下： #include #...
数据结构-链表的C语言使用
03-25
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，...在实际编程中，链表常用于实现高级数据结构，如堆栈、队列、树等，以及算法，如LRU缓存淘汰策略。理解并熟练运用链表将极大地提升你的编程能力。
C语言-数据结构-栈队列实现
03-10
这些文件共同构成了一个完整的C语言数据结构库，实现了栈和队列的基本操作，可以用于各种需要此类数据结构的计算机程序中。了解并熟练掌握这些基础知识对于任何想深入学习C语言或计算机科学的人来说都是至关重要的。
数据结构-队列的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 队列的部分实现代码，详细介绍参考数据结构--队列的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
c语言实现队列功能
11-04
c语言实现队列功能，push、pop多字节与单字节，方便调用。
队列的实现（C语言）
m0_70403090的博客
09-11 466
插入新数据首先要开辟空间建立一个新的结构体，然后在尾部插入data。如果是第一个数据，head和tail就会指向同一位置，如果不是，tail需要往前移动到newnode的位置，最后size++。首先判断队列是不是为空，如果只有一个数据时，删除后head和tail都需要指向空。注意删除的是先进入队列的数据，最后size--。队列依然用单向链表实现，同时需要另一个结构体表示头尾指针，队列是一种先进先出的数据结构。如图为队列数据的大致思想，关于head和tail指向不同位置的数据。6.返回head位置的数据。
C简单队列实现
ahducheng的博客
11-01 264
#include #include #defineMAX20 //类型 typedefstructnode{ intdata[MAX]; inthead; inttail; }queue_t; //创建 voidcreate_queue(queue_t*queue)
队列的实现（C语言版）
C12345bbbbbb的博客
11-06 322
我们约定front指向队头的前一个元素，rear指向队尾元素。随着元素的添加，数组会存满。但是当我们取出元素之后，低端还有空位置。这种现象叫做假溢出。我们解决的办法就是当存满之后，继续往下标最小的位置延续。这样的顺序队列，我们称为循环队列。只允许一端插入，在另一端删除操作的线性表。允许插入操作的一端称为队尾，允许删除操作的一端称为队头。满足先进先出的特性。队列的顺序存储结构也称为顺序队列。二.队列的顺序存储结构。
队列——（c语言实现）
2302_77041624的博客
05-12 1135
队列，是一种先进先出（first in first out 简称FIFO）的数据结构，是只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，在队列中，进行插入的一端称为队尾，进行删除的一端称为队头。
Objective-C 队列实现
北京的开始
04-15 3625
Objective-C 队列实现 原贴地址：http://blog.csdn.net/cloudhsu/article/details/6589313   Objective-C同样没有提供Queue容器,因此我也自己实践了一个 #import @interface NSQueue : NSObject { NSMutableArray* m_array;
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值