C语言 队列

最新推荐文章于 2024-04-24 16:09:08 发布
最新推荐文章于 2024-04-24 16:09:08 发布
阅读量256 收藏
点赞数
文章标签： 开发语言 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/againknow/article/details/131212456
版权

目录

一、队列概念

二、基础数组队列

三、基础链表队列

四、数组队列 -- 函数

五、链表队列 -- 函数

一、队列概念

先进先出，后进后出
第一个元素无数据
数组队列长度 -- 根据数组长度决定
链表队列长度 -- 根据电脑内存决定

二、基础数组队列

#include <stdio.h>
#include <malloc.h>
// 队列: 先进先出，后进后出
// 循环队列 -- 数组
// 最大存储个数 MAXSIZE-1
// 队列第一个无数据

// 队空：queue->front == queue->rear
// 队满：(queue->rear + 1) % MAXSIZE == queue->front

#define MAXSIZE 3

typedef struct {
    int data[MAXSIZE];
    // 头指针
    int front;
    // 尾指针
    int rear;
}SqQueue;

int main()
{
    int inData = 100;
    int outData = 0;

    // 定义队列指针
    SqQueue* queue;
    // 申请队列内存
    queue = (SqQueue*)malloc(sizeof(SqQueue));
    // 头尾指针初始化
    queue->front = queue->rear = 0;

    // 入队
    if ((queue->rear + 1) % MAXSIZE == queue->front)
    {
        printf("队列已满，入队失败\n");
    }
    else
    {
        queue->rear = (queue->rear + 1) % MAXSIZE;
        queue->data[queue->rear] = inData;
        printf("%d\n", queue->data[queue->rear]);
    }

    // 出队
    if (queue->front == queue->rear)
    {
        printf("队列已空，出队失败\n");
    }
    else
    {
        queue->front = (queue->front + 1) % MAXSIZE;
        outData = queue->data[queue->front];
        printf("%d\n", outData);
    }
}

三、基础链表队列

#include <stdio.h>
#include <malloc.h>
/// <summary>
/// 链表队列: 先进先出，后进后出
/// 第一个元素无数据
/// 队列长度根据电脑内存为准
/// 
/// 队空：queue->front == queue->rear
/// 队满：p == NULL
/// </summary>
typedef struct QNode
{
	int data;
	struct QNode* next;
}QNode,*QueuePtr;
typedef struct
{
	QueuePtr front, rear;
}LinkQueue;

int main()
{
	int inData = 100;
	int outData = 0;
	// 定义队列
	LinkQueue* queue;
	// 定义节点
	QNode* node;
	// 队列<头指针>申请内存
	queue = (LinkQueue*)malloc(sizeof(LinkQueue));
	// 队列<头节点>申请内存
	node = (QNode*)malloc(sizeof(QNode));
	
	// 队列初始化
	node->next = NULL;
	// 头尾指针指向第一个节点
	queue->front = queue->rear = node;

	//--------------------------------------------------------
	#pragma region 入队
	QNode* p;
	//创建新节点
	p = (QNode*)malloc(sizeof(QNode));
	if (p == NULL)
	{
		printf("电脑内存不足，申请失败\n");
	}
	p->data = inData;
	p->next = NULL;
	// 新节点 入队
	queue->rear->next = p;
	// 队列尾指针指向 新节点
	queue->rear = p;
	#pragma endregion

	//--------------------------------------------------------
	#pragma region 出队
	QNode* ptr;
	if (queue->front == queue->rear)
	{
		printf("队列已空\n");
	}
	else
	{
		// 获取头指针的数据
		ptr = queue->front->next;
		outData = ptr->data;
		printf("outData: %d\n", outData);
		// 出队
		queue->front->next = ptr->next;
		// 最后一个元素出队
		if (ptr->next == NULL)
		{
			queue->rear = queue->front;
		}
		// 释放空间
		free(ptr);
	}
	#pragma endregion	
}

四、数组队列 -- 函数

ArrayQueue.h

#ifndef __ARRAYQUEUE_H__
#include <stdio.h>
#include <malloc.h>

#define MAXSIZE 100
typedef int DataType;

typedef struct
{
	DataType data[MAXSIZE];
	int front;
	int rear;
}SqQueue;

SqQueue* InitQueue(void);
int QueueIsEmpty(SqQueue* queue);
int QueueIsFull(SqQueue* queue);
int QueueLength(SqQueue* queue);
int QueueGetHead(SqQueue* queue, DataType* e);
int EnQueue(SqQueue* queue, DataType e);
int DeQueue(SqQueue* queue, DataType* e);
int QueueTraverse(SqQueue* queue);
#endif // !__ARRAYQUEUE_H__

ArrayQueue.c

#include "ArrayQueue.h"

/// <summary>
/// 队列初始化
/// </summary>
/// <param name="queue"></param>
/// <returns></returns>
SqQueue* InitQueue(void)
{
	SqQueue* queue;
	queue = (SqQueue*)malloc(sizeof(SqQueue));
	queue->front = queue->rear = 0;
	return queue;
}

/// <summary>
/// 判断队列是否为空
/// </summary>
/// <param name="queue"></param>
/// <returns></returns>
int QueueIsEmpty(SqQueue* queue)
{
	return queue->front == queue->rear ? 1 : 0;
}

/// <summary>
/// 判断队列是否已满
/// </summary>
/// <param name="queue"></param>
/// <returns></returns>
int QueueIsFull(SqQueue* queue)
{
	return queue->front == (queue->rear+1)%MAXSIZE ? 1 : 0;
}

/// <summary>
/// 获取队列当前长度
/// </summary>
/// <param name="queue"></param>
/// <returns></returns>
int QueueLength(SqQueue* queue)
{
	// +MAXSIZE -- 防止为负数的情况
	return (queue->rear - queue->front + MAXSIZE) % MAXSIZE;
}

/// <summary>
/// 获取当前头节点的数据
/// </summary>
/// <param name="queue"></param>
/// <param name="e"></param>
/// <returns></returns>
int QueueGetHead(SqQueue* queue, DataType* e)
{	
	// 若队列为空
	if (QueueIsEmpty(queue))
	{
		// 失败
		return 0;
	}
	// 获取首节点数据
	*e = queue->data[queue->front];
	// 成功
	return 1;
}

/// <summary>
/// 入队
/// </summary>
/// <param name="queue"></param>
/// <param name="e"></param>
/// <returns></returns>
int EnQueue(SqQueue* queue, DataType e)
{
	// 若队列已满
	if (QueueIsFull(queue))
	{
		return 0;
	}
	// 队列添加数据
	queue->data[queue->rear] = e;
	// 队列尾指针后移
	queue->rear = (queue->rear + 1) % MAXSIZE;
	return 1;
}

/// <summary>
/// 出队
/// </summary>
/// <param name="queue"></param>
/// <param name="e"></param>
/// <returns></returns>
int DeQueue(SqQueue* queue, DataType* e)
{
	// 若队列为空
	if (QueueIsEmpty(queue))
	{
		return 0;
	}
	// 获取头数据
	*e = queue->data[queue->front];
	// 头指针后移
	queue->front = (queue->front + 1) % MAXSIZE;
	return 1;
}

/// <summary>
/// 队列遍历
/// </summary>
/// <param name="queue"></param>
/// <returns></returns>
int QueueTraverse(SqQueue* queue)
{
	int i;
	// 若队列为空
	if (QueueIsEmpty(queue))
	{
		return 0;
	}
	i = queue->front;
	while (i != queue->rear)
	{
		printf("%d ", queue->data[i]);
		i = (i + 1) % MAXSIZE;
	}
	printf("\n");
	return 1;
}

main.c 

#include <stdio.h>
#include "ArrayQueue.h"

int main()
{
	SqQueue* queue;
	DataType result;

	// 队列初始化
	queue = InitQueue();	

	// 入队
	EnQueue(queue, 100);
	EnQueue(queue, 200);
	
	// 获取首元素
	QueueGetHead(queue, &result);
	printf("%d\n", result);

	// 获取队列长度
	result = QueueLength(queue);
	printf("%d\n", result);

	// 队列遍历
	QueueTraverse(queue);

	// 出队
	DeQueue(queue, &result);
	printf("%d\n", result);
}

五、链表队列 -- 函数

LinkQueue.h

#ifndef __LINKQUEUE_H__
#include <stdio.h>
#include <malloc.h>

typedef int DataType;

typedef struct QNode
{
	DataType data;
	struct QNode* next;
}QNode;
typedef struct
{
	QNode *front, *rear;
}SqQueue;

SqQueue* InitQueue(void);
int QueueIsEmpty(SqQueue* queue);
int QueueLength(SqQueue* queue);
int QueueGetHead(SqQueue* queue, DataType* e);
int EnQueue(SqQueue* queue, DataType e);
int HeadEnQueue(SqQueue* queue, DataType e);
int DeQueue(SqQueue* queue, DataType* e);
int QueueTraverse(SqQueue* queue);
#endif // !__LINKQUEUE_H__

LinkQueue.c 

#include "LinkQueue.h"

/// <summary>
/// 队列初始化
/// </summary>
/// <returns></returns>
SqQueue* InitQueue(void)
{
	SqQueue* queue;
	QNode* node;
	
	queue = (SqQueue*)malloc(sizeof(SqQueue));
	node = (QNode*)malloc(sizeof(QNode));

	node->next = NULL;
	// 头尾指针指向第一个节点
	queue->front = queue->rear = node;
	
	return queue;
}

/// <summary>
/// 判断队列是否为空
/// </summary>
/// <param name="queue"></param>
/// <returns></returns>
int QueueIsEmpty(SqQueue* queue)
{
	return queue->front == queue->rear ? 1 : 0;
}

/// <summary>
/// 获取队列元素的个数
/// </summary>
/// <param name="queue"></param>
/// <returns></returns>
int QueueLength(SqQueue* queue)
{
	QNode* p;
	int i = 0;
	p = queue->front;
	while (p != queue->rear)
	{
		i++;
		p = p->next;
	}
	return i;
}

/// <summary>
/// 获取首个元素
/// </summary>
/// <param name="queue"></param>
/// <param name="e"></param>
/// <returns></returns>
int QueueGetHead(SqQueue* queue, DataType* e)
{
	*e = queue->front->next->data;
	return 1;
}

/// <summary>
/// 入队
/// </summary>
/// <param name="queue"></param>
/// <param name="e"></param>
/// <returns></returns>
int EnQueue(SqQueue* queue, DataType e)
{
	QNode* p;
	p = (QNode*)malloc(sizeof(QNode));
	// 若电脑内存不足
	if (p == NULL)
	{
		return 0;
	}
	// 数据添加
	int a = sizeof(p->data) / sizeof(DataType);
	p->data = e;
	p->next = NULL;
	// 新节点 --  连接
	queue->rear->next = p;
	// 尾指针后移
	queue->rear = p;

	return 1;
}

/// <summary>
/// 队列头插入
/// </summary>
/// <param name="queue"></param>
/// <param name="e"></param>
/// <returns></returns>
int HeadEnQueue(SqQueue* queue, DataType e)
{
	QNode* p;
	p = (QNode*)malloc(sizeof(QNode));
	// 若电脑内存不足
	if (p == NULL)
	{
		return 0;
	}
	// 数据添加
	p->data = e;
	// 新节点 -- 连接
	p->next = queue->front->next;
	// 头指针前移
	queue->front->next = p;

	return 1;
}

/// <summary>
/// 出队
/// </summary>
/// <param name="queue"></param>
/// <param name="e"></param>
/// <returns></returns>
int DeQueue(SqQueue* queue, DataType* e)
{
	QNode* p;
	// 若队列为空
	if (QueueIsEmpty(queue))
	{
		return 0;
	}
	// 获取头节点
	p = queue->front->next;
	// 获取数据
	*e = p->data;
	// 出队
	queue->front->next = p->next;
	// 若是最后一个节点
	if (p->next == NULL)
	{
		queue->rear = queue->front;
	}
	// 节点释放
	free(p);
	return 1;
}

/// <summary>
/// 队列遍历
/// </summary>
/// <param name="queue"></param>
/// <returns></returns>
int QueueTraverse(SqQueue* queue)
{
	// 获取第一个节点
	QNode* p = queue->front->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		// 指针后移
		p = p->next;
	}
	printf("\n");
	return 1;
}

 main.c

#include <stdio.h>
#include "LinkQueue.h"

int main()
{
	SqQueue* queue;
	DataType result;

	// 队列创建
	queue = InitQueue();

	// 入队
	EnQueue(queue, 100);
	HeadEnQueue(queue, 200);
	HeadEnQueue(queue, 300);

	// 队列遍历
	QueueTraverse(queue);

	// 队列元素个数
	result = QueueLength(queue);
	printf("%d \n", result);
	
	// 获取队列首元素
	QueueGetHead(queue, &result);
	printf("%d \n", result);

	// 出队
	DeQueue(queue, &result);
	printf("%d \n", result);
	DeQueue(queue, &result);
	printf("%d \n", result);
}

如有错误，烦请批评指正

**启程**
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言队列的实现及头文件
12-28
在自身写C实现二叉树时所写的队列的实现代码，内附代码和头文件，在头文件中修改 QueueType 的define还有 InputQueue 函数就可以适配其余功能例如其他结构体。 初始QueueTpye 为int型
C语言数据结构005——队列
weixin_45084986的博客
06-28 5724
一、队列的基本概念 (1)定义:只能在表的一端进行插入操作，在表的另一端进行删除操作的线性表。 (2)特点：先进先出 示意图如下： 二、顺序存储结构的队列 有6个存储空间的顺序队列动态示意图 顺序队列的“假溢出”问题 ①假溢出 顺序队列因多次入队列和出队列操作后出现的虽有存储空间但不能进行入队列操作的情况。 ②如何解决顺序队列的假溢出问题？ 可采取四种方法： 1)采用循环队列； 2)按最大可能的进队操作次数设置顺序队列的最大元素个数； 3)修改出队算法，使每次出队列后都把队列中剩余数据元素向队头方向移动
【数据结构】C语言队列(详解)
weixin_65186652的博客
08-31 5325
C语言实现队列,详细解读
队列（C语言实现）
m0_59311392的博客
09-18 1583
1.1 定义：队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out)入队列：进行插入操作的一端称为队尾出队列：进行删除操作的一端称为队头int front;int rear;}QueNode;int size;}Queue双端队列是指允许两端都可以进行入队和出队操作的队列。其元素的逻辑结构仍是线性结构。将队列的两端称为前端和后端，两端都可以入队和出队。
C语言实现队列
热门推荐
m0_60447315的博客
03-26 1万+
📋 个人简介 💖 作者简介：大家好，我是菀枯😜 🎉 支持我：点赞👍+收藏⭐️+留言📝 💬格言：不要在低谷沉沦自己，不要在高峰上放弃努力！☀️ 前言 前一段时间，我们试着用C语言实现了数据结构中的顺序表，单链表，双向循环链表，栈😃。今天我们再用C语言来实现另一种特殊的线性结构：队列 一. 什么是队列 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（head）进行删除操作，而在表的后端（tail）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除
C语言---队列(详解）---数据结构
weixin_57535054的博客
02-11 6796
队列所需要的头文件 先给类型重命名 意义前几篇有讲 队列要用到的两个结构体 第一个结构体里面有 1.存储数据的 a 2.指向下一个节点的指针 重命名为Queue（这里的名字需要记一下，等会需要分辨两个结构体，结构体两个的功能是不一样的） 第二个结构体里面有 1.指向头的头指针 2.指向尾的尾指针 重命名尾Qnene 队列实现的函数功能有： 1.初始化队列 2.队尾入数据 3.队头出数据 4.获取队列的有效元素个数 5.判断队列是否为空 6.获取队列头部数据7.获...
C语言-队列
Discod_lim的博客
03-21 1348
队列的基本操作
数据结构——队列（C语言实现）
sinzz的博客
04-16 2694
首先，我们需要定义的是链式结构的队列，即单链表为底层实现的。所以需要定义单链表结构来存储数据。然后，定义队列，队列里需要定义两个指向单链表的指针，一个是指向单链表头结点的指针，另一个则用来保存尾结点地址的指针。最后，还需定义一个记录当前队列元素个数的变量，用于遍历队列和判空。int size;} Queue;
c语言实现队列
m0_61438674的博客
10-05 5232
c语言实现队列
queue_C语言队列_
10-02
c语言实现的队列，采用内存分配数组方式实现
队列模型_c语言队列模型_
09-29
应用队列（M/M/1）编程思想，模拟单服务器顾客排队等待服务的过程，顾客到达时间和服务时间均按指数分布生成；当排队人数超过队伍最大 长度时，显示输出人数超过服务器范围并且结束程序；当服务器有空闲状态时， ...
C语言 队列 函数
04-30
自己编写的C语言队列函数，实现方法清晰明了
C语言队列的基本操作
02-20
C语言队列的基本操作 入队 出队 对的初始化
开发语言漫谈-脚本语言
wangbing1125的博客
04-20 676
前面讲的都称之为编程语言，就是做系统用的。还有一大类称之为脚本语言的语言，这类语言数量极多，大部分程序员用不上，也不关心，这是系统维护人员专用的邻域。更准确的来讲，能直接运行的文本都可以称之为脚本语言，按这个标准，python也是。ruby是日本人松本行弘发明的一种面向对象编程的脚本语言，大量借鉴了Perl、Smalltalk、Eiffel、Ada以及Lisp语言的优点，曾经风靡一时，但现在有点没落了。N多年后，可能现在的很多编程语言消失了，但是只要linux还在，bash就在。它在游戏届那是相当的有名。
C语言 | Leetcode C语言题解之第45题跳跃游戏II
m0_59237910的博客
04-23 350
C语言 | Leetcode C语言题解之第45题跳跃游戏II
数据结构——树和二叉树的基本概念
最新发布
qq_67693066的博客
04-24 1045
数据结构——树和二叉树的基本概念
数据结构中的栈和队列（附实际案例代码）
JAZJD的博客
04-23 749
栈（Stack）和队列（Queue）
【做算法学数据结构】二叉树的层序遍历【二叉树】
yh4494的博客
04-24 726
`二叉树`是一种常见的树形数据结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树的特点是每个节点最多有两个子节点，并且子节点的顺序是有序的，即左子节点在前，右子节点在后。
数据结构 -- 二叉树&二叉搜索树
2301_79602614的博客
04-20 1418
这样看似prev = node.val 也就是 prev = 5,但因为你的prev是作为一个参数,是对整个方法中生效的,也就是4这个点有doValid(node.left,prev) 和 doValid(node.right,prev)这两个prev都是4这个点传入的prev并不会说因为在doValid(node.prev)中prev=5导致这个方法的所有prev都变为了5,本质也就是这个参数只是这个方法的局部变量,局部变量的修改不会影响到其他的方法。如何知道右子树处理完成呢？
c语言队列的链式实现
10-20
C语言队列的链式实现是通过链表来实现的，这种队列被称为链式队列。链式队列是一种同时带有队头指针和队尾指针的单链表，头指针指向队头结点，尾指针指向队尾结点。队列的入队操作是通过不断next指针连接，在队尾...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值