【C数据结构】非循环队列和循环队列（链表与顺序表实现）

最新推荐文章于 2022-08-25 14:10:30 发布
最新推荐文章于 2022-08-25 14:10:30 发布
阅读量652 收藏 3
点赞数 2
分类专栏： 数据结构 文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ahaooooooo/article/details/126185890
版权

文章目录

1、认识队列

在这里插入图片描述

队列的一大特点就是先进先出，后如后出。队列是有序的，从头出，从尾入。

一个很形象的应用就是医院的挂号机，有序的每次叫队列队头的号码，机器每次从记录的队尾加数据。

2、队列实现

一个队列需要实现的操作如下。

  1. 入队
  2. 出队
  3. 查看队头
  4. 查看队尾
  5. 计算队长度

结构的选择有顺序表和链表，从优缺点来看。

  1. 入队，顺序表和链表尾插的效率都一样，但在空间上链表更好，不会浪费空间。
  2. 出队，顺序表头删的效率低于链表头删的效率。
  3. 查看队头，都比较容易。
  4. 查看队尾，顺序表比较容易，链表需要遍历在尾部查看，如果没有建立尾指针的话。
  5. 计算对长度，顺序表本身记录了，链表需要遍历计算。

似乎都有自己擅长的领域，那么都实现一遍吧。

3、非循环队列单链表写法

3.1、测试页和头文件

为了在实现一些功能上更加的便利，在创建队列的结构体中创建头尾指针变量，以及一个size记录长度。

头文件中

//Queue.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int QDataType;

typedef struct QueueNode 
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;

//队列结构体 有效避免二级指针
typedef struct Queue 
{
	QueueNode* front;
	QueueNode* tail;
	int size;
}Queue;

//初始化队列
void QueueInit(Queue* pq);

//销毁队列
void QueueDestroy(Queue* pq);

//入队
void QueuePush(Queue* pq, QDataType x);

//出队
void QueuePop(Queue* pq);

//返回队头数据
QDataType QueueFront(Queue* pq);

//返回队尾数据
QDataType QueueBack(Queue* pq);

//队列大小
int QueueSize(Queue* pq);

//判空
bool QueueEmpty(Queue* pq);

测试文件中

//Test.c
#include"Queue.h"
void QueueTest1() 
{
	Queue p;
	QueueInit(&p);
	QueuePush(&p, 1);
	QueuePush(&p, 2);
	QueuePush(&p, 3);
	///*QueuePop(&p);
	//QueuePop(&p);
	//QueuePop(&p);*/
	printf("%d\n", QueueSize(&p));
	while (!QueueEmpty(&p))
	{
		printf("%d ",QueueFront(&p));
		QueuePop(&p);
	}
	QueueDestroy(&p);
}


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

 

3.2、接口函数的实现

队列的函数实现比较容易

#include"Queue.h"

//初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);

	pq->front = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

//销毁队列
//从头到尾一次一个结点销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* p = pq->front;
	while (p)
	{
		QueueNode* cur = p;
		p = p->next;
		free(cur);
	}
	pq->front = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

//入队
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	
	//先创建新结点
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	
	//入队
	if (pq->front == NULL)
	{
		pq->front = newnode;
		pq->tail = pq->front;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = pq->tail->next;
	}

	pq->size++;
}

//出队
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	QueueNode* p = pq->front;
	pq->front = pq->front->next;
	free(p);

	pq->size--;
}

//看头
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->front->data;
}

//看尾
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}

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

//看空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->front == NULL;
}

4、非循环队列顺序表写法

4.1、测试页和头文件

头文件中

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

typedef int QDataType;
typedef struct Queue
{
	int size;
	int capacity;
	QDataType* a;
}Queue;


//初始化队列
void QueueInit(Queue* pq);

//销毁队列
void QueueDestroy(Queue* pq);

//入队
void QueuePush(Queue* pq, QDataType x);

//出队
void QueuePop(Queue* pq);

//返回队头数据
QDataType QueueFront(Queue* pq);

//返回队尾数据
QDataType QueueBack(Queue* pq);

//队列大小
int QueueSize(Queue* pq);

//判空
bool QueueEmpty(Queue* pq);

测试文件中

//Test.c
#include"Queue.h"
void QueueTest1() {
	Queue p;
	QueueInit(&p);
	QueuePush(&p, 1);
	QueuePush(&p, 2);
	QueuePush(&p, 3);
	///*QueuePop(&p);
	//QueuePop(&p);
	//QueuePop(&p);*/
	printf("%d\n", QueueSize(&p));
	while (!QueueEmpty(&p))
	{
		printf("%d ",QueueFront(&p));
		QueuePop(&p);
	}
	QueueDestroy(&p);
}


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

4.2、接口函数的实现

#include"Queue.h"

//初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->a = NULL;
	pq->size = -1;
	pq->capacity = -1;
}

//销毁队列
void QueueDestroy(Queue* pq)
{
	assert(pq);

	free(pq->a);
	pq->size = pq->capacity = 0;
}

//入队
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	if (pq->size == pq->capacity)
	{
		//扩容
		int newcapacity = pq->capacity == -1 ? 4 : pq->capacity;
		QDataType* tmp = (QDataType*)realloc(pq->a, sizeof(QDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("malloc fail");
			exit(-1);
		}

		pq->a = tmp;
		pq->capacity = newcapacity;
	}
	++pq->size;
	pq->a[pq->size] = x;
}

//出队
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	int i = 0;
	for (i = 0; i < pq->size; i++)
	{
		pq->a[i] = pq->a[i + 1];
	}

	pq->size--;
}

//返回队头数据
QDataType QueueFront(Queue* pq)
{
	assert(!QueueEmpty(pq));
	return pq->a[0];
}

//返回队尾数据
QDataType QueueBack(Queue* pq)
{
	assert(!QueueEmpty(pq));
	return pq->a[pq->size];
}

//队列大小
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size + 1;
}

//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == -1;
}

 

5、循环队列的实现

循环队列的实现概念来自一个leetcode上的题。

设计循环队列
在这里插入图片描述

循环队列的逻辑图
在这里插入图片描述
在题目要求中，我们需要完成：

  1. 队列创建
  2. 获取队头队尾数据
  3. 插入删除
  4. 判空，判满

值得注意的是，队列的长度在一开始就确定，所以是个静态的。

那么，对于循环队列的结构我们选链表还是顺序表?

 

6、循环队列单链表写法

如果选择链表

  1. 队列创建，一开始我们就需要循环创建一个长度为K的链表，这个链表有着队头和队尾指针。
  2. 获取队头队尾数据，只需要通过队头队尾指针获取。
  3. 插入删除，由于链表长度固定，插入就是尾指针指向的data直接赋值，删除就让队头指针到下一个位置。
  4. 判空，判满，这个似乎很复杂，下面讨论一下这两种情况。

链表结构的判空与判满：

在创建好 K=6 的链表后，front和back分别表示队头和队尾指针，这个时候如果插入数据，back会有两种插入表示方法，第一种back位置直接插入，front不动back++，这种情况判空很容易，当front和back相等的时候队列为空。
在这里插入图片描述

如果一直往下插入，当在back位置插入后，back又回到了front位置，这个时候队列是满的，但与队空的情况出现一致，所以这种方式还是有问题的。
在这里插入图片描述

那么就想，在这个循环队列中，能否每次多开辟一个空间，使得back能够在队满的时候能和front有一个距离，并且使得每次插入的操作都是一样的。

所以此时，每当back->next==front时，队列为满。
在这里插入图片描述
 
代码实现

typedef int SLDataType;
typedef struct STList
{
    struct STList* next;
    SLDataType data;
}SL;

typedef struct {
    SL* head;
    SL* front;
    SL* back;
} MyCircularQueue;

//声明
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

//创建队列
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->head = obj->front = obj->back = NULL;
    //建立循环链表 为了更方便判断队列为空以及队列为满的情况 还是建立K+1的队列长度
    int i = 0;
    for (i = 0; i <= k; i++)
    {
        SL* newnode = (SL*)malloc(sizeof(SL));
        newnode->next = NULL;
        if (obj->head == NULL)
        {
            obj->head = obj->front = obj->back = newnode;
        }
        else
        {
            obj->back->next = newnode;
            obj->back = newnode;
        }
    }
    //尾接头 构成循环
    obj->back->next = obj->front;
    obj->back = obj->front;

    return obj;
}

//队列插入数据
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->back->data = value;
        obj->back = obj->back->next;
        return true;
    }
}

//队列删除数据
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front = obj->front->next;
        return true;
    }
}

//看队头数据
int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->front->data;
    }
}

//看队尾数据
int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        SL* p = obj->front;
        while (p->next != obj->back)
        {
            p = p->next;
        }
        return p->data;
    }
}

//判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->back == obj->front;
}

//判满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->back->next == obj->front;
}

//摧毁队列
void myCircularQueueFree(MyCircularQueue* obj) {
    obj->back = obj->head;
    obj->front = obj->head;
    //将back至尾
    while (obj->back->next != obj->head)
    {
        obj->back = obj->back->next;
    }

    //从头开始一个一个删结点
    while (obj->head != obj->back)
    {
        obj->head = obj->head->next;
        free(obj->front);
        obj->front = obj->head;
    }
    free(obj->back);
    obj->head = obj->front = obj->back = NULL;
    free(obj);
    obj = NULL;

}

在这里插入图片描述
 
 

7、循环队列顺序表写法

如果使用顺序表：

  1. 队列创建，开辟一块连续的固定空间，依然是有容量和当前大小。
  2. 获取队头队尾数据，只需要通过下标0和当前大小来获取。
  3. 插入删除，插入数据就size++，删除就size–。
  4. 判空，判满，依然需要我们讨论。
  5. 顺序表的循环的实现：在size大于k值的时候，需要对size取余数，这样就很好实现了循环。

顺序表结构的判空与判满：
K=6
同样是多建立一个空间，但这也使得，如果我们在改变size的时候，都需要考虑一下size是否大于k+1，能够实现循环效果。
在这里插入图片描述
代码实现

typedef int QDataType;
typedef struct {
    int k; //队列长度
    QDataType* a;
    int front;
    int back;
} MyCircularQueue;

//声明
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

//创建队列
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (QDataType*)malloc(sizeof(QDataType) * (k + 1)); //多开一个空间
    obj->k = k + 1;
    obj->front = obj->back = 0;

    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (!myCircularQueueIsFull(obj))
    {
        obj->back = (obj->back) % (obj->k); //实现循环效果
        obj->a[obj->back] = value;
        obj->back++;

        return true;
    }
    else
    {
        return false;
    }
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (!myCircularQueueIsEmpty(obj))
    {
        obj->front++;
        obj->front = (obj->front) % (obj->k); //实现循环效果
        return true;
    }
    else
    {
        return false;
    }
}

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

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        if (obj->back == 0)
        {
            obj->back = obj->k;
        }
        return obj->a[obj->back - 1];
    }
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->back;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (((obj->back) + 1) % (obj->k)) == obj->front;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    obj->k = obj->front = obj->back = 0;
    free(obj);
}

在这里插入图片描述

本章完。

Ahao_te
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构学习笔记（队列）
weixin_44779139的博客
05-15 234
目录 前言 一、队列的顺序存储结构 1.顺序队列的定义 2.非循环队列 1）非循环队列的实现 2）非循环队列的缺陷 3.循环队列 1）循环队列的定义 2）循环队列的实现 二、队列的链式存储结构 1.链队 1）链队的定义 2）链队的实现 3）链队的应用 总结 前言 队列与栈类似，也是一种线性结构。但与栈不同，队列结构遵循的原则是先进先出。队列（队）只能在表的一端进行插入，在另一端进行删除。通常把插入的一端称为队尾，删除的一端称为队首。向队中插入元素称为入队，删除称为出队 如
循环队列的数组实现方式与链表实现方式
单线程的Daniel的博客
12-27 527
假设front指向队列的头部，rear指向队列的尾部。 则队列满的条件是：(rear+1)%QueueSize==front 则队列为空的条件为：rear==front 通用的计算队列长度的公式：(rear-front+QueueSize)%QueueSize 则队列的数组实现如下： private int[] array; private int front; private int rea...
数据结构（2）队列实现（queue）
cdut2016的博客
09-07 1384
一、队列介绍 1、队列是一个有序列表，可以用数组或者链表实现。 2、遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。 3、示意图： 数组模拟队列 1、队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。 2、因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及 rear分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear则是随着数据输入而改变，如图所示: 思路： 当我们将数
【数据结构】循环队列的实现
记录学习点滴
08-24 5044
>✨给大家推荐一款很火爆的刷题、面试求职网站✨
两种非循环顺序队列的表示和实现（第三章）
但行好事，莫问前程
03-20 341
两种非循环顺序队列的表示和实现 第一种： 存储空间可增，队头元素总在 [0] 单元，所以不必设头指针。它的缺点是元素出队时需要移动大量元素，尤其在队列较长时，效率较低。 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FAL...
头歌 顺序表，链表，循环队列的基本操作和应用答案。
05-03
这里我们讨论的是顺序表、链表以及循环队列，这些都是基本的数据结构，广泛应用于算法设计和程序实现中。 顺序表是一种线性数据结构，它在内存中按顺序连续存储元素。它的主要操作包括插入、删除和查找。在顺序表中...
链表-使用Python基于链表实现的多种队列数据结构比较.zip
最新发布
03-13
本资料包“链表-使用Python基于链表实现的多种队列数据结构比较”着重探讨了如何利用Python语言来实现不同类型的队列数据结构，其中队列是一种先进先出（FIFO）的数据结构，常用于任务调度、缓冲区管理和多线程通信...
C语言数据结构之判断循环链表空与满
08-29
在C语言数据结构中，判断循环链表空与满是一个重要的知识点。本文将详细介绍循环链表的空和满的判断方法，并提供相应的代码实现。 何时队列为空？何时为满？由于入队时尾指针向前追赶头指针，出队时头指针向前追赶...
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列
10-19
在IT领域，数据结构是计算机科学中的核心概念，它...在C_DataStructure-master这个项目中，你可以找到这些数据结构的具体C语言实现，通过阅读源代码，可以加深对它们的理解，并学习如何在实际编程中应用这些基础知识。
C数据结构循环链表实现约瑟夫环
01-01
C数据结构循环链表实现约瑟夫环 本文代码均在turbo C 2.0 的环境下运行通过，并得到正确结果，本程序为用循环链表实现约瑟夫环，即有m个人站成一个圆环，从某人（队列第一个）开始报数，约定从某数开始的第n个人出列...
循环队列（用顺序表来实现）
罗汉松驻扎的工作基地
10-13 753
//怎样使顺序循环队列不损失一个空间，并且又能判断队列已经满了呢？？ //只要多设计一个标志tag  当tag=0时表示出队， 当tag=1时表示入队 //队列为空  front==rear && tag==0 //队列为满  front==rear && ta
用顺序表实现队列（循环队列）
weixin_47511190的博客
08-14 388
#include<bits/stdc++.h> using namespace std; //用顺序表实现队列（循环队列） #define MaxSize 5 struct Queue{ int data[MaxSize]; //数据元素 int front,back; //队头 队尾 int size; //队列中元素个数 }; //初始化队列 void InitQueue(Queue *&Q){ Q=(Queue *)malloc(sizeof(Queue))
循环队列的实现
hellolde的博客
07-18 214
循环队列 由于队列的入队和出队分别在线性表的两端不同于栈的一端操作，如果直接用顺序表来表示队列，则出队操作比较麻烦，每次出队都要移动整个队列的元素，但不移动又会浪费顺序表前面的存储空间。为了解决这个问题，提出来循环队列的思想，即将顺序表的表头和表尾连在一起，同时用front和rear两个指针分别指向循环队列的队头和队尾。 循环队列的描述方法如下： #define MAXQSIZE 256 //队列的最大长度 typedef struct SeqQueue { ElemType* pBase;
c语言中如何写一循环链表队列,C语言数据结构——线性表链式循环队列(链表实现方式)...
weixin_26833939的博客
05-21 396
队列相关知识及操作请参看上一章一、链式队列链式队列 ： 用链表形式实现的队列。链表结点为队列数据存储区，链表结点包括两部分数据存储区和指针存储区。数据存储区 ：存放真实有效数据的区域。指针存储区 ：存放下一个链表结点的地址。注意：1. 链式队列不存在队列已满的情况。在内存足够大的情况下，每次动态申请链表结点内存都会成功，即不会出现队列已满的情况，除非数据量超大内存不够。2. 链式队列只存在队列为空...
单链表循环队列
Acceleration_的博客
04-28 4203
// // 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.
实现队列（链表实现）和循环队列（数组实现）
lzqgzh的博客
08-14 327
队列的概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头 （Head/Front） 实现队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据效率会比较低。 1.使用链表实现队列 package queue; public class My...
循环队列（链表、数组）
m0_65213200的博客
08-25 709
循环队列（数组、链表）
队列——循环队列与非循环队列（Java版）
weixin_42468092的博客
06-15 1506
import java.awt.Font; import java.util.Scanner; import javax.management.RuntimeErrorException; public class CircleArrayQueueDemo { public static void main(String[] args) { //创建队列 CircleArrayQueue circleArrayQueue = new CircleArrayQueue(4); char k
[数据结构][适用循环队列和非循环队列]顺序队列的实现。
Jper_mr的专栏
08-08 1576
队列是队尾添加元素，队头删除元素，先进先出的线性结构，当队列为顺序队列即非循环队列的时候，当队头位置和队尾位置相同都为0的时候，队列为空队列，当队列为循环队列的时候，队列满和空时队头元素位置和队尾元素位置都是相等的。那为什么这个下面的代码可以适用于非循环队列和循环队列呢，原因就在于判断队列为空和满的条件，即当当(rear+1) % MAXSIZE = front时为满这个条件，下面分析一下这个条件

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值