队列和循环队列

最新推荐文章于 2025-03-23 10:12:45 发布
最新推荐文章于 2025-03-23 10:12:45 发布
阅读量218 收藏
点赞数 1
文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_60128287/article/details/124794786
版权
本文介绍了两种循环队列的实现，一种是链表结构的循环队列，另一种是固定大小数组的循环队列。在链表结构中，详细展示了初始化、入队、出队和打印操作。对于数组循环队列，强调了在入队时要对头指针进行取余操作以避免溢出，同时展示了完整的添加、删除和输出过程。通过对队列操作的优化，实现了O(1)的时间复杂度。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一.队列

        1老师的代码

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

typedef struct LinkNode{
    int data;
    struct LinkNode* next;
}*LinkNodePtr;

typedef struct LinkQuene{
    LinkNodePtr front;
    LinkNodePtr rear;
}*LinkQuenePtr;

LinkQuenePtr initQuene(){
    LinkQuenePtr resultPtr=(LinkQuenePtr)malloc(sizeof(struct LinkQuene));
    LinkNodePtr headerPtr=(LinkNodePtr)malloc(sizeof(struct LinkNode));
    headerPtr->next=NULL;

    resultPtr->front=headerPtr;
    resultPtr->rear=headerPtr;
    
    return resultPtr;
}

void outputLinkQuene(LinkQuenePtr paraQuenePtr){
    LinkNodePtr tempPtr=paraQuenePtr->front->next;
    while(tempPtr!=NULL){
        printf("%d",tempPtr->data);
        tempPtr=tempPtr->next;
    }
    printf("\r\n");
}

void enquene(LinkQuenePtr paraQuenePtr,int paraElement){
    LinkNodePtr tempNodePtr=(LinkNodePtr)malloc(sizeof(struct LinkNode));
    tempNodePtr->data=paraElement;
    tempNodePtr->next=NULL;

    paraQuenePtr->rear->next=tempNodePtr;

    paraQuenePtr->rear=tempNodePtr;
}

int dequene(LinkQuenePtr paraQuenePtr){
    int resultValue;
    LinkNodePtr tempNodePtr;

    if(paraQuenePtr->front==paraQuenePtr->rear){
        printf("The quene is empty\r\n");
        return -1;
    }

    tempNodePtr=paraQuenePtr->front->next;
    resultValue=tempNodePtr->data;
    paraQuenePtr->front->next=paraQuenePtr->front->next->next;

    if(paraQuenePtr->rear==tempNodePtr){
        paraQuenePtr->rear=paraQuenePtr->front;
    }

    free(tempNodePtr);
    tempNodePtr=NULL;

    return resultValue;
}


void testLinkQuene(){
    LinkQuenePtr tempQuenePtr;
    tempQuenePtr=initQuene();

    enquene(tempQuenePtr,10);
    enquene(tempQuenePtr,30);
    enquene(tempQuenePtr,50);

    outputLinkQuene(tempQuenePtr);

    printf("dequene gets %d\r\n",dequene(tempQuenePtr));
    printf("dequene gets %d\r\n",dequene(tempQuenePtr));
    printf("dequene gets %d\r\n",dequene(tempQuenePtr));
    printf("dequene gets %d\r\n",dequene(tempQuenePtr));

    enquene(tempQuenePtr,8);
    outputLinkQuene(tempQuenePtr);
}
int main(){
    testLinkQuene();
    return 1;
}

         运行结果

 

 2.自己的代码

        2.1结构体


typedef struct node{
	int data;
	struct node* next;
}*Nodeptr;

typedef struct quene{
	Nodeptr header;
	Nodeptr tail;
}*Queneptr;

        2.2初始化


Queneptr init(){
	Queneptr t=(Queneptr)malloc(sizeof(struct quene));
	Nodeptr q=(Nodeptr)malloc(sizeof(struct node));
	
    /*初始化头结点*/
	q->data=0;q->next=NULL;
	
    /*初始化队列*/
	t->header=q;
	t->tail=q;
	
	return t;
}

        2.3打印


void printQuene(Queneptr p){
	Nodeptr t=p->header->next;
	
    /*循环输出data*/
	while(t!=NULL){
		printf("%d ",t->data);
		t=t->next;
	}
	printf("\r\n");
}

       

        2.4添加.入队


void add(Queneptr p,int value){
    /*将数值存入*/
	Nodeptr t=(Nodeptr)malloc(sizeof(struct node));
	t->data=value;
	t->next=NULL;
	
    /*改变尾指针*/
	p->tail->next=t;
	p->tail=t;
}

     仅在队尾入队操作

 

          2.5删除.出队


int deletenode(Queneptr p){
	int value;
	Nodeptr t;
	
    /*判断表是否为空*/
	if(p->header==p->tail){
		printf("ERROR! empty\r\n");
		return -1;
	}
	
    /*取出队头值*/
	t=p->header->next;
	value=t->data;

    /*移动头指针*/
	p->header->next=t->next;
	
    /*若删除末尾结点，使尾指针与头指针相同*/
	if(p->tail==t)
		p->tail=p->header;
	
	free(t);
	t=NULL;
	
    /*返回队头值*/
	return value;
}

   仅在队头进行出队操作

 

            2.6测试


void test(){
    /*初始化*/
	Queneptr t=init();
	printf("初始化：\r\n");
	printQuene(t);
	
    /*添加测试*/
	printf("添加：\r\n");
	add(t,1);
	add(t,9);
	add(t,9);
	add(t,4);
	printQuene(t);
	printf("\n");
	
    /*删除测试*/
	printf("删除：\r\n");
	printf("delete %d\r\n",deletenode(t));
	printf("delete %d\r\n",deletenode(t));
	printf("delete %d\r\n",deletenode(t));
	printf("delete %d\r\n",deletenode(t));
	printf("delete %d\r\n",deletenode(t));
	printf("\n");
	
	printf("再次添加：\r\n");
	add(t,19940221);
	printQuene(t);
}

        2.7完整代码

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

typedef struct node{
	int data;
	struct node* next;
}*Nodeptr;

typedef struct quene{
	Nodeptr header;
	Nodeptr tail;
}*Queneptr;

Queneptr init(){
	Queneptr t=(Queneptr)malloc(sizeof(struct quene));
	Nodeptr q=(Nodeptr)malloc(sizeof(struct node));
	
    /*初始化头结点*/
	q->data=0;q->next=NULL;
	
    /*初始化队列*/
	t->header=q;
	t->tail=q;
	
	return t;
}

void printQuene(Queneptr p){
	Nodeptr t=p->header->next;
	
    /*循环输出data*/
	while(t!=NULL){
		printf("%d ",t->data);
		t=t->next;
	}
	printf("\r\n");
}

void add(Queneptr p,int value){
    /*将数值存入*/
	Nodeptr t=(Nodeptr)malloc(sizeof(struct node));
	t->data=value;
	t->next=NULL;
	
    /*改变尾指针*/
	p->tail->next=t;
	p->tail=t;
}

int deletenode(Queneptr p){
	int value;
	Nodeptr t;
	
    /*判断表是否为空*/
	if(p->header==p->tail){
		printf("ERROR! empty\r\n");
		return -1;
	}
	
    /*取出队头值*/
	t=p->header->next;
	value=t->data;

    /*移动头指针*/
	p->header->next=t->next;
	
    /*若删除末尾结点，使尾指针与头指针相同*/
	if(p->tail==t)
		p->tail=p->header;
	
	free(t);
	t=NULL;
	
    /*返回队头值*/
	return value;
}

void test(){
    /*初始化*/
	Queneptr t=init();
	printf("初始化：\r\n");
	printQuene(t);
	
    /*添加测试*/
	printf("添加：\r\n");
	add(t,1);
	add(t,9);
	add(t,9);
	add(t,4);
	printQuene(t);
	printf("\n");
	
    /*删除测试*/
	printf("删除：\r\n");
	printf("delete %d\r\n",deletenode(t));
	printf("delete %d\r\n",deletenode(t));
	printf("delete %d\r\n",deletenode(t));
	printf("delete %d\r\n",deletenode(t));
	printf("delete %d\r\n",deletenode(t));
	printf("\n");
	
	printf("再次添加：\r\n");
	add(t,19940221);
	printQuene(t);
}

void main(){
	test();
}

        运行结果

 

二.循环队列

        1.老师的代码(小改动)

在入队操作时有点小错误，header的值也要取余，因为header递增，会超过给定长度

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

#define TOTAL_SPACE 5

typedef struct CircleIntQuene{
    int data[TOTAL_SPACE];
    int head;
    int tail;
}*CircleIntQuenePtr;

CircleIntQuenePtr initQuene(){
    CircleIntQuenePtr resultPtr=(CircleIntQuenePtr)malloc(sizeof(struct CircleIntQuene));
    resultPtr->head=0;
    resultPtr->tail=0;

    return resultPtr;
}

void enquene(CircleIntQuenePtr paraPtr,int paraValue){
    if((paraPtr->tail+1)%TOTAL_SPACE==((paraPtr->head)%TOTAL_SPACE)){
        printf("Quene full.\r\n");
        return;
    }

    paraPtr->data[paraPtr->tail%TOTAL_SPACE]=paraValue;
    paraPtr->tail++;
    printf("tail = %d\r\n",paraPtr->tail);
}

int dequene(CircleIntQuenePtr paraPtr){
    int resultValue;
    if(paraPtr->head==paraPtr->tail){
        printf("No element in the queen.\r\n");
        return -1;
    }

	printf("header = %d\r\n",paraPtr->head);
    resultValue=paraPtr->data[paraPtr->head%TOTAL_SPACE];
    paraPtr->head++;

    return resultValue;
}


void outputLinkQuene(CircleIntQuenePtr paraPtr){
    int i;
    if(paraPtr->head==paraPtr->tail){
        printf("Empty quene.\r\n");
        return ;
    }
    
    printf("Element in the quene:");
    for(i=paraPtr->head;i<paraPtr->tail;++i){
        printf("%d, ",paraPtr->data[i%TOTAL_SPACE]);
    }
    printf("\r\n");
}

void testLinkQuene(){
    int i=10;
    CircleIntQuenePtr tempPtr=initQuene();
    for(;i<16;i++){
        enquene(tempPtr,i);
    }

    outputLinkQuene(tempPtr);

    for(i=0;i<6;i++){
        printf("dequene gets %d\r\n",dequene(tempPtr));
    }

    enquene(tempPtr,8);
    enquene(tempPtr,1);
    enquene(tempPtr,9);
    enquene(tempPtr,9);
    enquene(tempPtr,4);
    
    outputLinkQuene(tempPtr);
    
    dequene(tempPtr);
    dequene(tempPtr);
    dequene(tempPtr);
    dequene(tempPtr);
    printf("AFTER DELETE :\r\n");
    outputLinkQuene(tempPtr);
    
    printf("SECOND \r\n");
    enquene(tempPtr,8);
    enquene(tempPtr,1);
    enquene(tempPtr,9);
    enquene(tempPtr,9);
    enquene(tempPtr,4);
    
    
    outputLinkQuene(tempPtr);
    
}

int main(){
    testLinkQuene();
    return 1;
}

未改的运行结果，可以看到第二次添加时溢出了

令header也取余，运行结果正确

 

 

2.自己的代码

        2.1结构体


typedef struct Circlequene{
	int data[LENGTH];
	int header;
	int tail;
}*Cqueneptr;

        2.2初始化


Cqueneptr init(){
	Cqueneptr t=(Cqueneptr)malloc(sizeof(struct Circlequene));

	t->header=0;
	t->tail=0;
	
	return t;
}

        2.3打印


void printQuene(Cqueneptr p){
    /*判断是否为空*/
    if(p->header==p->tail){
    	printf("\r\n");
        return ;
    } 
    
    printf("打印：");
    int i;

    /*循环打印data值*/
    for(i=p->header;i<p->tail;++i){
        printf("%d ",p->data[i%LENGTH]);
    }
    printf("\r\n");
}

        2.4入队


void add(Cqueneptr p,int Value){
    /*判断是否已满*/
    /*header也要取余，因为header也是递增的，会超过LENGTH*/
    if((p->tail+1)%LENGTH==((p->header)%LENGTH)){
        printf("ERROR! 已满\r\n");
        return;
    }

    /*将值存入*/
    p->data[p->tail%LENGTH]=Value;
    p->tail++;
    printf("tail = %d\r\n",p->tail);
}

       第一步：逐个入队，4加入后tail为4，此时判断队列已满

 第二步：逐个删除，header为4，与tail相等，此时判断队列已空

 第三步：再次加入，tail值递增，在2号位加入7后，tail值为8，再次判断队列已满，此时若再次出队操作，header也会为8，超过了LENGTH=5，因此header也应取余

 

         2.5出队


int deleteC(Cqueneptr p){
    /*判断是否为空*/
    if(p->header==p->tail){
        printf("ERROR! 空表\r\n");
        return -1;
    }

    /*取出队头值，并改变头指针*/
	printf("header = %d\r\n",p->header);
	int result;
    result=p->data[p->header%LENGTH];
    p->header++;

    return result;
}

        2.6测试


void test(){
    /*初始化*/
	Cqueneptr t=init();
	printf("初始化：\r\n");
	printQuene(t);
	
    /*添加测试*/
	printf("添加：\r\n");
	add(t,1);
	add(t,9);
	add(t,9);
	add(t,4);
	add(t,2);
	printQuene(t);
	printf("\n");
	
    /*删除测试*/
	printf("删除：\r\n");
	printf("delete %d\r\n",deleteC(t));
	printf("delete %d\r\n",deleteC(t));
	printf("delete %d\r\n",deleteC(t));
	printf("delete %d\r\n",deleteC(t));
	printf("delete %d\r\n",deleteC(t));
	printf("\n");
	
    /*再次添加，检查header超过LENGTH后，是否出现异常*/
	printf("再次添加：\r\n");
	add(t,0);
	add(t,7);
	add(t,1);
	add(t,7);
	add(t,10);
	printf("删除后：\r\n");
	printQuene(t);
	
	printf("删除 2 ：\r\n");
	deleteC(t);
	printQuene(t);
}

        2.7完整代码

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

#define LENGTH 5
typedef struct Circlequene{
	int data[LENGTH];
	int header;
	int tail;
}*Cqueneptr;


Cqueneptr init(){
	Cqueneptr t=(Cqueneptr)malloc(sizeof(struct Circlequene));

	t->header=0;
	t->tail=0;
	
	return t;
}

void printQuene(Cqueneptr p){
    /*判断是否为空*/
    if(p->header==p->tail){
    	printf("\r\n");
        return ;
    } 
    
    printf("打印：");
    int i;

    /*循环打印data值*/
    for(i=p->header;i<p->tail;++i){
        printf("%d ",p->data[i%LENGTH]);
    }
    printf("\r\n");
}

void add(Cqueneptr p,int Value){
    /*判断是否已满*/
    /*header也要取余，因为header也是递增的，会超过LENGTH*/
    if((p->tail+1)%LENGTH==((p->header)%LENGTH)){
        printf("ERROR! 已满\r\n");
        return;
    }

    /*将值存入*/
    p->data[p->tail%LENGTH]=Value;
    p->tail++;
    printf("tail = %d\r\n",p->tail);
}

int deleteC(Cqueneptr p){
    /*判断是否为空*/
    if(p->header==p->tail){
        printf("ERROR! 空表\r\n");
        return -1;
    }

    /*取出队头值，并改变头指针*/
	printf("header = %d\r\n",p->header);
	int result;
    result=p->data[p->header%LENGTH];
    p->header++;

    return result;
}

void test(){
    /*初始化*/
	Cqueneptr t=init();
	printf("初始化：\r\n");
	printQuene(t);
	
    /*添加测试*/
	printf("添加：\r\n");
	add(t,1);
	add(t,9);
	add(t,9);
	add(t,4);
	add(t,2);
	printQuene(t);
	printf("\n");
	
    /*删除测试*/
	printf("删除：\r\n");
	printf("delete %d\r\n",deleteC(t));
	printf("delete %d\r\n",deleteC(t));
	printf("delete %d\r\n",deleteC(t));
	printf("delete %d\r\n",deleteC(t));
	printf("delete %d\r\n",deleteC(t));
	printf("\n");
	
    /*再次添加，检查header超过LENGTH后，是否出现异常*/
	printf("再次添加：\r\n");
	add(t,0);
	add(t,7);
	add(t,1);
	add(t,7);
	add(t,10);
	printf("删除后：\r\n");
	printQuene(t);
	
	printf("删除 2 ：\r\n");
	deleteC(t);
	printQuene(t);
}

void main(){
	test();
}

        运行结果

初始化：

添加：
tail = 1
tail = 2
tail = 3
tail = 4
ERROR! 已满
打印：1 9 9 4

删除：
header = 0
delete 1
header = 1
delete 9
header = 2
delete 9
header = 3
delete 4
ERROR! 空表
delete -1

再次添加：
tail = 5
tail = 6
tail = 7
tail = 8
ERROR! 已满
删除后：
打印：0 7 1 7
删除 2 ：
header = 4
打印：7 1 7

队列仅仅在队首，对尾进行出队，入队操作，因此怎加和删除的时间复杂度都是O(1)，并且有先进先出的特点。

循环队列则是通过下标的巧妙运算，充分利用空间，形成逻辑上的环。

--WEN--
关注
[数据结构] 队列与循环队列
weixin_43717520的博客
05-23 494
队列与循环队列
链队列和循环队列
m0_61608863的博客
05-17 797
队列是一种先进先出（FIFO）的线性表，它只允许在表的一端进行插入，而在另一端删除元素。这和我们日常生活中的排队是一致的，最早进入队列的元素最早离开。队列的结构图如下所示： 明白了队列之后，链队列就非常简单了，用链表表示的队列就简称为链队列。一个链队列显然需要两个分别指示队头和队尾的指针(分别称为头指针和尾指针)才能惟一确定。 图片转载 //链队列结构定义 //链队列节点 typedef struct LinkNode { int data; struct LinkNode* next; }
队列及循环队列
2303_79383388的博客
03-23 795
队列及循环队列笔记
队列与循环队列
qq_47259418的博客
05-14 969
队列与循环队列1.队列1.1队列的定义1.2队列的基本介绍1.3用数组模拟实现队列1.3.1数据模拟队列示意图1.3.2数组模拟队列的思路1.4代码实现队列2.循环队列2.1循环队列的定义2.2循环队列的基本介绍2.3用数组模拟实现循环队列2.3.1数组模拟循环队列的思路2.4 代码实现 1.队列 1.1队列的定义   队列是一种只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 1.2队列的基本介绍   1）队列是一个有序列表，可以通过数组和链表来实现   2）队列遵循着先进先出的原则。即：先存入
队列 和 循环队列
weixin_43154720的博客
10-18 497
队列也是一种运算受限制的线性表，它只允许在表的一端进行插入，而另外一段只允许进行删除。 允许删除的一端称为队头（Front);允许删除的一端称为队尾（Rear)。 顺序队列实际上是受限的顺序表，和顺序表一样，顺序队列也必须采用一个数组来存放当前数据元素。 当队尾（Rear)达到 最大位置时（Maxsize)。 表示此时空间不足，已经不能在入队了。但是随着我们出队Front 向前移动， (0~Front) 的空间是剩余的。 我们称这种现象为假上溢。 为了克服假上溢现象：我们讲队列的头尾连起来形成一个环
链队列和循环队列数据结构实验.docx
11-17
在实验报告中，学生可以选择不同的题目进行实践，比如实现顺序栈和链式栈，链队列和循环队列，或者使用栈解决实际问题，如3阶汉诺塔问题。每个题目都要求编写程序，进行调试和运行，并通过实验报告展示程序的正确性...
链队列和循环队列数据结构实验.pdf
10-01
链队列和循环队列数据结构实验报告 本实验报告主要介绍了链队列和循环队列数据结构的实验内容，涵盖了链队列和循环队列的基本概念、数据类型描述、存储表示、基本操作算法实现和实际应用。 一、链队列数据结构 链...
java队列实现方法(顺序队列,链式队列,循环队列)
08-28
Java 中提供了多种实现队列的方法，包括顺序队列、链式队列和循环队列等。下面我们将详细介绍每种队列的实现方法和特点。 一、顺序队列 顺序队列是指使用数组来实现队列的数据结构。它的特点是元素在数组中的位置...
【数据结构】队列及循环队列
HelloCode
05-27 1002
🌟个人博客：www.hellocode.top🌟 ⭐所有文章均在上方博客首发，其他平台同步更新 🔥本文专栏：《数据结构与算法》 ⚡如有问题，欢迎指正，一起学习~~ 文章参考整理自小码哥的《恋上数据结构和算法》课程，图片转载自课程PPT，如有侵权，请联系删除~~ 文章目录队列接口设计代码实现双端队列接口设计代码实现循环队列接口设计代码实现循环双端队列接口设计代码实现 队列是一种只允许在一端进行插入，另一端进行删除先进先出的线性表 和栈有相似之处（只许在一端插入删除，先进后出），可以进行对比的理解和.
一，队列以及循环队列
qq_61858706的博客
05-17 133
一，队列 1，队列创建 typedef struct LinkNode { int data; struct LinkNode *next; }*ListPtr,LNode; typedef struct LinkQueue { ListPtr front; ListPtr rear; }*LinkQueuePtr,LNodeQueue; 创建两个指针跟踪链表，front指向链表头，rear指向连尾。 2，初始化队列 LinkQueuePtr initQueue() { LinkQ
队列和循环队列的实现
GodBMW的博客
06-18 632
队列 定义：队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（head）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 按照队列的定义，结合内存地址的理解，初始化队列的时候，准备head和rear指针分别指向头和尾。Push操作，只需要改变rear指针；PopLeft操作只需要改变head。由
队列 -- 循环队列
小神兵之技术篇
07-09 4611
实现队列的方法有很多，比如链表，动态数组等，这里主要介绍一下循环队列，首先我们用静态数组做个简单的队列：从上图很显然可以看出，全部出队后，将无法继续入队，这样的情况也叫做“假溢出”，即使数组中，明明还有空间可以利用，但是却无法使用。为了解决这样的问题，就引入了一个叫“循环队列”这
【数据结构】详解队列和循环队列
m0_52094687的博客
12-23 2722
该博客讲了队列的概念及结构，使用C语言实现队列，又简绍了循环队列，并且通过Leetcode上的一道题，实现循环队列
单向队列和循环队列(c)
qq_38412637的博客
04-20 1204
关于队列 队列可分为顺序表队列 也可以为链式队列，这里小编为了便于理解，是用顺序表做队列，队列是一种先进先出的数据结构，它的特性是只能在一段进行入队（添加数据操作 对头），在另一端进行出对（删除，读取操作 队尾）; 分别设三个属性 最大容量（capaticy），头指针(head) 尾指针tail, 队列的长度为tail-head 这幅图是模拟了一个队列的四种状态:, 因此，可以看到 队列满的情...
数据结构篇——队列的操作实现（队列、循环队列）！
jjq20020211的博客
07-28 1581
本文主要介绍了用数组和链表实现队列以及用数组实现循环队列的方法，并附有完整代码。
优先队列和循环队列的区别
最新发布
04-18
嗯，用户问的是优先队列和循环队列的区别，这两个都是队列的变种，但区别应该挺大的。首先得先回忆一下队列的基本概念，队列是先进先出的结构。循环队列是为了解决普通队列假溢出的问题，用数组实现的时候，通过模...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值