数据结构之队列的相关实现（C语言）

最新推荐文章于 2023-11-05 14:26:00 发布
最新推荐文章于 2023-11-05 14:26:00 发布
阅读量246 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44519040/article/details/119651278
版权

参考：1.网课：数据结构与算法基础（青岛大学-王卓）
2.教材：数据结构（c语言版）第二版，严蔚敏，李冬梅等著

非科班自学，如有错误望不吝赐教。

链队

0.基本操作

一个链队包括一个头指针和尾指针，链队有头结点，链表方向从队头指向队尾，头指针始终指向头结点，尾指针指向尾结点
链栈只有栈顶指针,始终指向队尾结点

#include <stdio.h>
#include <malloc.h>
#define Max 100
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define INFEASIBLE -1
typedef int Status;
typedef int QElemType;


//队列的链式储存结构
typedef struct  QNode{//链队结点包括数据域和指针域
    QElemType data;//数据域
    struct  QNode  *next;//指针域
}QNode,*QueuePtr;

typedef struct{//一个链队包括一个头指针和尾指针，
//链队有头结点，头指针始终指向头结点
    QueuePtr front;//队头指针
    QueuePtr rear;//队尾指针
}LinkQueue;

//链队的初始化
Status  InitQueue(LinkQueue* QQ){
    (*QQ).front=(QueuePtr)malloc(sizeof(QNode));
    (*QQ).front->next=NULL;
    (*QQ).rear=(*QQ).front;
    return  OK;
}

//链队的入队
Status EnQueue(LinkQueue* QQ,QElemType a){
    QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
    p->data=a;
    p->next=NULL;
    (*QQ).rear->next=p;
    (*QQ).rear=p;
    printf("En%d ",a);
    return  OK;
}


//链队的出队
Status  DeQueue(LinkQueue*  QQ,QElemType* e){
    if((*QQ).front==(*QQ).rear) return  ERROR;  //判断是否队空
    QueuePtr p=(*QQ).front->next;
    *e=p->data;
    (*QQ).front->next=p->next;
    if((*QQ).rear==p) (*QQ).rear=(*QQ).front;//如果出队的是尾结点
    free(p);
    printf("De%d ",*e);
    return  OK;
}

//销毁队列：从头结点开始依次释放所有结点
Status  DestroyQueue(LinkQueue* QQ){
    while((*QQ).front){
         QueuePtr p=(*QQ).front->next;
        free((*QQ).front);
        (*QQ).front=p;
    }
}

//取队头元素，不修改队头指针
QElemType GetHead(LinkQueue Q){
    if(Q.front==Q.rear) return  ERROR;
    return  Q.front->next->data;
}

//打印链队
Status PrintQueue(LinkQueue Q){
    QueuePtr p=Q.front->next;
    printf("print:");
    while(p) {
    printf("%d ",p->data);
    p=p->next;
    }
    return OK;
}

//简单调试
int main(){
    int m;
    int i=0;
    QElemType a;//入队的元素
    QElemType e;//出队的元素
    LinkQueue   Q;
    InitQueue(&Q);
    printf("请输入原始队列的元素个数：");
    scanf("%d",&m);
    for(i=0;i<m;i++){
        printf("请输入入队的元素：");
        scanf("%d",&a);
         EnQueue(&Q,a);
    }
    PrintQueue(Q);
    DeQueue(&Q,&e);
    printf("出队的元素为%d ",e);
    PrintQueue(Q);
}

注：结构体起别名

1.带头节点的循环链表表示队列，只设一个指针指向队尾元素节点（不设头指针）

设计置空队列，判断队列是否为空，入队和出队等算法

#include <stdio.h>
#include <malloc.h>
#define Max 100
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define INFEASIBLE -1
typedef int Status;
typedef int QElemType;
//带头节点的循环链表表示队列，只设一个指针指向队尾元素节点（不设头指针）
//置空队列，判断队列是否为空，入队和出队等算法

//队列的链式储存结构
typedef struct  QNode{//链队结点包括数据域和指针域
    QElemType data;//数据域
    struct  QNode  *next;//指针域
}QNode,*QueuePtr;


typedef struct{
    QueuePtr rear;//队尾指针
}LinkQueue2;

//链队的初始化
Status  InitQueue2(LinkQueue2* QQ){
    (*QQ).rear=(QueuePtr)malloc(sizeof(QNode));
    (*QQ).rear->next=(*QQ).rear;
    return  OK;
}

//链队的入队
Status EnQueue2(LinkQueue2* QQ,QElemType a){
    QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
    p->data=a;
    p->next=(*QQ).rear->next;
    (*QQ).rear->next=p;
    (*QQ).rear=p;
    printf("En %d",a);
    return  OK;
}


//链队的出队
Status  DeQueue2(LinkQueue2*  QQ,QElemType* e){
    if((*QQ).rear==(*QQ).rear->next) {printf("the queue is empty"); return  ERROR;}  
    QueuePtr p=(*QQ).rear->next->next;
    *e=p->data;
    (*QQ).rear->next->next=p->next;
    if((*QQ).rear==p) (*QQ).rear=p->next;//如果出队的是尾结点
    free(p);
    printf("De %d",*e);
    return  OK;
}

//销毁队列：从头结点开始依次释放所有结点
Status  DestroyQueue2(LinkQueue2* QQ){
    while((*QQ).rear){
         QueuePtr p=(*QQ).rear->next;
        (*QQ).rear->next=p->next;
        free(p);
    }
}


//取队头元素，不修改队头指针
QElemType GetHead2(LinkQueue2 Q){
    if(Q.rear==Q.rear->next) return  ERROR;
    return  Q.rear->next->next->data;
}

//打印链队
Status PrintQueue2(LinkQueue2 Q){
    QueuePtr p=Q.rear->next->next;
    printf("print:");
    while(p!=Q.rear->next) {
    printf("%d ",p->data);
    p=p->next;
    }
    return OK;
}
//简单调试
int main(){ 
    int m;
    int i=0;
    QElemType a;//入队的元素
    QElemType e;//出队的元素
    LinkQueue2   Q;
    InitQueue2(&Q);
    printf("Please enter the number of elements in the original queue: ");
    scanf("%d",&m);
    for(i=0;i<m;i++){
        printf("Please enter the elements of the queue: ");
        scanf("%d",&a);
         EnQueue2(&Q,a);
    }
    PrintQueue2(Q);
    DeQueue2(&Q,&e);
    PrintQueue2(Q);
	printf("the head is %d ",GetHead2(Q));

}

顺序队

0.基本操作（牺牲一个空间）

循环顺序队包含数组（基地址），头指针（数组下标），尾指针（数组下标）
头指针指向队头元素，尾指针指向队尾元素的下一个
注意循环如何表示：一般要模max，且式子是减法时还要加max避免负数模max的情况
front=rear:Queue is empty
(rear+1)%Max=front：Queue is full

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define Max 8
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define INFEASIBLE -1
typedef int Status;
typedef int QElemType;


//队列的顺序储存结构
typedef struct{
    QElemType *base;//存储空间的基地址
    int front;//头指针，指向队头元素
    int rear;//尾指针，指向队尾元素后面一个
}SqQueue;


//初始化
Status InitQueue(SqQueue* QQ){
    (*QQ).base=(QElemType*)malloc(sizeof(QElemType)*Max);
    if(!(*QQ).base) exit(OVERFLOW);
    (*QQ).front=(*QQ).rear=0;
    return OK;
} 

//求队列长度
int QueueLength(SqQueue Q){
    return (Q.rear-Q.front+Max) % Max;
}


//入队
Status EnQueue(SqQueue *QQ,QElemType a){
    if(((*QQ).rear+1)%Max==(*QQ).front){printf("Queue is full");return ERROR;}//判断队满
    (*QQ).base[(*QQ).rear]=a;
    (*QQ).rear=((*QQ).rear+1)% Max;
    printf("En %d",a);
    return OK;
}

//出队
Status DeQueue(SqQueue *QQ,QElemType* e){
    if((*QQ).front==(*QQ).rear){printf("Queue is empty");return ERROR;};//判断队空
    *e=(*QQ).base[(*QQ).front];
    (*QQ).front=((*QQ).front+1)%Max;
    printf("De %d",*e);
    return OK;
}

//打印顺序队
Status PrintQueue(SqQueue Q){
    if(Q.front==Q.rear) {printf("Queue is empty");return ERROR;};//判断队空
    int p=Q.front;
    printf("print:");
    while(p!=Q.rear){
        printf("%d ",Q.base[p]);
        p=(p+1)%Max;
    }
}

//简单调试
int main(){
    SqQueue Q;
    InitQueue(&Q);
    int m;
    int i;
    QElemType a;//存放入队元素
    QElemType e;//存放出队元素
    printf("Please enter the length of the original queue:");
    scanf("%d",&m);
    for(i=0;i<m;i++){
        printf("Please %dth data:",i+1);
        scanf("%d",&a);
        EnQueue(&Q,a);
    }
    
    for(i=0;i<3;i++){
        DeQueue(&Q,&e);
    }
    for(i=0;i<m;i++){
        printf("Please %dth data:",i+1);
        scanf("%d",&a);
        EnQueue(&Q,a);
    }
    PrintQueue(Q);

}

1.设置tag的不牺牲数组存储空间的循环顺序队

循环顺序队包含数组（基地址），头指针（数组下标），尾指针（数组下标）
头指针指向队头元素，尾指针指向队尾元素的下一个
注意循环如何表示：一般要模max，且式子是减法时还要加max避免负数模max的情况
用tag表示上一次操作是入队还是出队
rear=front&&tag=0 :Queue is empty 指针重叠，且上一次操作是出队
rear=front&&tag=1 :Queue is full 指针重叠，且上一次操作是入队

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define Max 8
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define INFEASIBLE -1
typedef int Status;
typedef int QElemType;




//队列的顺序储存结构
typedef struct{
    QElemType *base;//存储空间的基地址
    int front;//头指针，指向队头元素
    int rear;//尾指针，指向队尾元素后面一个
}SqQueue;


//初始化
Status InitQueue(SqQueue* QQ){
    (*QQ).base=(QElemType*)malloc(sizeof(QElemType)*Max);
    if(!(*QQ).base) exit(OVERFLOW);
    (*QQ).front=(*QQ).rear=0;
    return OK;
} 

//求队列长度
int QueueLength(SqQueue Q){
    return (Q.rear-Q.front+Max) % Max;
}



//入队
Status EnQueue(SqQueue *QQ,QElemType a,int* tagptr){
    if((*QQ).rear==(*QQ).front&&*tagptr ) {
        printf("Queue is full");
        return ERROR;}//判断队满:两个指针重合，且上一次操作是入队
    (*QQ).base[(*QQ).rear]=a;
    (*QQ).rear=((*QQ).rear+1)% Max;
    printf("En %d",a);
    *tagptr=1;
    return OK;
}

//出队
Status DeQueue(SqQueue *QQ,QElemType* e,int* tagptr){
    if((*QQ).rear==(*QQ).front&&*tagptr==0 ) {printf("Queue is empty");return ERROR;}//判断队空:两个指针重合且上一次操作是出队
    *e=(*QQ).base[(*QQ).front];
    (*QQ).front=((*QQ).front+1)%Max;
    printf("De %d",*e);
    *tagptr=0;
    return OK;
}

//打印顺序队
Status PrintQueue(SqQueue Q,int tag){
    if(Q.rear==Q.front&&tag==0) {
        printf("Queue is empty");
        return ERROR;}//判断队空
    int p=Q.front;
    printf("print:");
    do//注意要先做一次循环，以免队满时（p==Q.rear）直接跳过循环
    {
        printf("%d ",Q.base[p]);
        p=(p+1)%Max;
    }while(p!=Q.rear);
    return OK;
}

//简单调试
int main(){
    SqQueue Q;
    InitQueue(&Q);
    int m;
    int i;
    QElemType a;//存放入队元素
    QElemType e;//存放出队元素
    int tag=0;
    printf("Please enter the length of the original queue:");
    scanf("%d",&m);
    for(i=0;i<m;i++){
        printf("Please %dth data:",i+1);
        scanf("%d",&a);
        EnQueue(&Q,a,&tag);
    }
    for(i=0;i<3;i++){
    DeQueue(&Q,&e,&tag);
    }
        for(i=0;i<5;i++){
        printf("Please %dth data:",i+1);
        scanf("%d",&a);
        EnQueue(&Q,a,&tag);
    }
    PrintQueue(Q,tag);
}

注：这篇博客写了队列的链式存储结构（牺牲一个存储空间/设置tag表示上次操作/设置变量记录每次操作后数组中元素个数）与顺序存储结构，很详细：队列的实现(c语言)

2.循环列队的两端操作

允许在循环队列的两端进行插入和删除操作，具体为如果允许在循环队列的两端都可以进行插入和删除操作。构造一个循环队列，实现从队头入队，从队尾出队并输出。约定从队头入队时向下标小的方向发展，从队尾入队时则向下标大的方向发展。
想法：
设置队头指针front和队尾指针rear,约定front指向队头元素的前位置， rear指向队尾元素。 定义满足 front- rear时为队空。从队尾删除元素，则rear向着下标减小的方向行走:从队头插入元素，front 同样向着下标减小的方向行走。因此，当满足rear==(front-1+maxSize)%maxSize时队满。

一只小暑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【循环队列、数据结构C++】如果循环队列的两端都可以进行插入和删除
asdf_song的博客
03-16 1884
【循环队列、C++】如果循环队列的两端都可以进行插入和删除（从队尾删除，从队头插入）题目要求完整代码 题目要求 如果允许在循环队列的两端都可以进行插入和删除操作。要求：写出“从队尾删除”和“从队头插入”的算法； 完整代码 #include <iostream > using namespace std; template <typename ElemType> struct Quene { ElemType* items; int head, tail;//队列的头、尾指针 i
数据结构--队列的实现（C语言）
COOL_jack的博客
06-18 298
目录声明一 队列的基本概念1.队列的基本定义2.队列的基本操作二 队列的顺序存储结构1.代码实现（C语言）2.循环队列三 队列的链式存储结构1.代码实现（C语言）四 双端队列 声明 以下内容仅供学习，如有侵权，联系作者删除。 参考文献：王道考研系列数据结构、B站up主：C语言技术网 链接: C语言技术网 一 队列的基本概念 1.队列的基本定义 队列（Queue）：也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。 队头（Front）：允许删除的一端。 队尾（Rear）：允许插入的一
基于两端操作的循环队列的实现
海月的博客
02-19 1555
#include <iostream> using namespace std; #define MAXSIZE 100 typedef struct { int *base; int front; int rear; }SqQueue; int InitQueue(SqQueue &Q) { Q.base=new int[MAXSIZE]; if(!Q.base...
考研数据结构之队列（3.3）——练习题之如果运行在循环队列的两端都可以进行插入和删除操作，写出从队尾删除和从队头插入的算法（C表示）
二木成林
05-31 7869
题目 如果允许在循环队列的两端都可以进行插入和删除操作，写出从队尾删除和从队头插入的算法。 分析 用一维数组data[0，....maxSize1]实现循环队列，其中maxSize是队列长度。设置队头指针front和队尾指针rear,约定front指向队头元素的前位置，rear指向队尾元素。定义满足front-rear时为队空。从队尾删除元素，则rear向着下标减小的方向行走:从队头插入元素，front同样向着下标减小的方向行走。因此，当满足rear==(front-1+maxSize...
编程题实训-队列
最新发布
a61233的博客
11-05 2518
第一行为两个整数n和m，n表示入队序列A的长度（n个数依次连续入队，中间没有出队的情况），m表示出队序列B的元素数量（m个数依次连续出队，中间没有入队的情况）。第二行为序列A（空格分隔的n个整数）。第一行为一个整数n，n表示入队序列A的长度（n个数依次连续入队，中间没有出队的情况），第二行为序列A（空格分隔的n个整数）。第一行为一个整数n，n表示入队序列A的长度（n个数依次连续入队，中间没有出队的情况），第二行为序列A（空格分隔的n个整数）。依次输出队列中所有的整数，每两个整数之间用空格分隔。
C语言数据结构链表队列的实现
12-31
C语言数据结构链表队列的实现 1.写在前面 　队列是一种和栈相反的，遵循先进先出原则的线性表。 　本代码是严蔚敏教授的数据结构书上面的伪代码的C语言实现代码。 　分解代码没有包含在内的代码如下： #include #...
数据结构 队列 插入元素 C语言
08-27
数据结构 队列 插入元素 C语言
数据结构 队列 删除元素 C语言
08-27
数据结构 队列 删除元素 C语言
数据结构循环队列的C语言实现
01-24
数据结构循环队列的C语言实现
队列练习之Example003-如果允许在循环队列的两端都可以进行插入和删除操作，分别写出从队尾删除和从队头插入的算法
二木成林
05-09 3652
如果允许在循环队列的两端都可以进行插入和删除操作，要求： - 写出循环队列的类型定义。 - 分别写出从队尾删除和从队头插入的算法。
循环队列两端的插入删除操作
SuiGi的博客
07-11 5449
/*允许在循环队列的两端都可以进行插入和删除操作 写出这样的循环队列类型定义+从队尾删除+从队头插入的算法*/ //私はあの弱い自分を認めない #ifndef PCH_H #define PCH_H #include<stdio.h> #include<iostream> #include<malloc.h> #include<cstdlib>//包...
BJFU_数据结构习题_248基于两端操作的循环队列的实现
雪地行进
10-26 2715
248基于两端操作的循环队列的实现 描述 如果允许在循环队列的两端都可以进行插入和删除操作。构造一个循环队列，实现从队头入队，从队尾出队并输出。约定从队头入队时向下标小的方向发展，从队尾入队时则向下标大的方向发展。 输入 多组数据，每组数据有两行。第一行为一个整数n，n表示入队序列A的长度（n个数依次连续入队，中间没有出队的情况），第二行为序列A（空格分隔的n个整数）。当n等于0时，输入结束。 输...
数据结构(C语言第2版) 课后习题答案之 第三章 栈和队列
热门推荐
Yummy的博客
04-12 1万+
目录 第3章 栈和队列 1．选择题 （2）回文是指正读反读均相同的字符序列，如“abba”和“abdba”均是回文，但“good”不是回文。试写一个算法判定给定的字符向量是否为回文。(提示：将一半字符入栈) （3）设从键盘输入一整数的序列：a1, a2, a3，…，an，试编写算法实现：用栈结构存储输入的整数，当ai≠-1时，将ai进栈；当ai=-1时，输出栈顶整数并出栈。算法应对异常情况（入栈满等）给出相应的信息。 （4）从键盘上输入一个后缀表达式，试编写算法计算表达式的值。规定：逆波兰表达..
数据结构-算法题分享1
weixin_46390041的博客
03-12 1432
本文主要是分享在练习过程中遇到的算法题。
循环队列的实现
等待飞翔的候鸟
05-15 819
<br />循环队列，如题，就是对队列实现循环存储，队列的头尾指针相连，而循环队列在C语言中不能通过实现动态分配一维数组实现存储，可定义循环队列如下<br />typedef struct{<br /> datatype *data;<br /> int front;<br /> int rear;<br />}sqQueue;//define a sqQueue<br />对循环队列的操作如下<br />void InitsqQueue(sqQueue &q){<br /> q.data=(datatyp
3.8循环队列队尾删除及队头插入算法
qq_39688282的博客
08-28 5912
题目：如果允许在循环队列的两端都可以进行插入和删除操作。要求： ① 写出循环队列的类型定义； ② 写出“从队尾删除”和“从队头插入”的算法。 ①定义循环队列： #define MAXSIZE 10; typedef struct{ Elemtype data[MAXSIZE]; int front;//队头指针 int rear;//队尾指针 }SqQueue; ②从队尾删除： Status DeQueue(SqQueue &S,int &x){ //&S为出队队列;x存
循环队列两端都可进行插入删除 （队尾删除，对头插入）
qq_39350434的博客
08-02 6459
#include &lt;iostream&gt; #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define maxsize 100 using namespace std; typedef struct { int data[maxsize]; int front,rear; }squeue; int desqueue(sq...
BJFU_数据结构习题_293基于链地址法的散列表的删除
雪地行进
11-26 1348
欢迎登录北京林业大学OJ系统 http://www.bjfuacm.com 293基于链地址法的散列表的删除 描述 请写出在散列表中删除关键字为k的一个记录的算法，设散列函数为H，H(key)=key%13，解决冲突的方法为链地址法。 输入 多组数据，每组三行，第一行为待输入的关键字的个数n，第二行为对应的n个关键字，第三行为需要删除的关键字k。当n=0时输入结束。 输出 每组数据输出用链地址法处...
C语言实现数据结构：队列详解
本章节主要探讨了两种数据结构：栈（Stack）和队列（Queue），以及它们在C语言中的实现和应用。 1. **栈（Stack）** - **顺序表示法**：栈是一种具有后进先出（LIFO）特性的数据结构，其操作包括在栈顶（top）插入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值