数据结构C语言实现系列——队列

最新推荐文章于 2022-04-12 16:36:34 发布
最新推荐文章于 2022-04-12 16:36:34 发布
阅读量717 收藏
点赞数
文章标签： 数据结构 语言 struct c null 存储
本文介绍了两种队列存储方式——链式存储与顺序存储的基本操作算法实现，包括初始化队列、向队列中插入和删除元素等核心功能，并通过实例演示了如何使用这些算法。

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

#include <stdio.h>
#include <stdlib.h>

typedef int elemType;
/************************************************************************/
/*                    以下是关于队列链接存储操作的6种算法               */
/************************************************************************/
struct sNode{
    elemType data;            /* 值域 */
    struct sNode *next;        /* 链接指针 */
};
struct queueLK{
    struct sNode *front;    /* 队首指针 */
    struct sNode *rear;        /* 队尾指针 */
};

/* 1.初始化链队 */
void initQueue(struct queueLK *hq)
{
    hq->front = hq->rear = NULL;        /* 把队首和队尾指针置空 */
    return;
}

/* 2.向链队中插入一个元素x */
void enQueue(struct queueLK *hq, elemType x)
{
    /* 得到一个由newP指针所指向的新结点 */
    struct sNode *newP;
    newP = malloc(sizeof(struct sNode));
    if(newP == NULL){
        printf("内存空间分配失败！ ");
        exit(1);
    }
    /* 把x的值赋给新结点的值域，把新结点的指针域置空 */
    newP->data = x;
    newP->next = NULL;
    /* 若链队为空，则新结点即是队首结点又是队尾结点 */
    if(hq->rear == NULL){
        hq->front = hq->rear = newP;
    }else{    /* 若链队非空，则依次修改队尾结点的指针域和队尾指针，使之指向新的队尾结点 */
        hq->rear = hq->rear->next = newP;        /* 注意赋值顺序哦 */
    }
    return;
}

/* 3.从队列中删除一个元素 */
elemType outQueue(struct queueLK *hq)
{
    struct sNode *p;
    elemType temp;
    /* 若链队为空则停止运行 */
    if(hq->front == NULL){
        printf("队列为空，无法删除！ ");
        exit(1);
    }
    temp = hq->front->data;        /* 暂存队尾元素以便返回 */
    p = hq->front;                /* 暂存队尾指针以便回收队尾结点 */
    hq->front = p->next;        /* 使队首指针指向下一个结点 */
    /* 若删除后链队为空，则需同时使队尾指针为空 */
    if(hq->front == NULL){
        hq->rear = NULL;
    }
    free(p);        /* 回收原队首结点 */
    return temp;    /* 返回被删除的队首元素值 */
}

/* 4.读取队首元素 */
elemType peekQueue(struct queueLK *hq)
{
    /* 若链队为空则停止运行 */
    if(hq->front == NULL){
        printf("队列为空，无法删除！ ");
        exit(1);
    }
    return hq->front->data;        /* 返回队首元素 */
}

/* 5.检查链队是否为空，若为空则返回1, 否则返回0 */
int emptyQueue(struct queueLK *hq)
{
    /* 判断队首或队尾任一个指针是否为空即可 */
    if(hq->front == NULL){
        return 1;
    }else{
        return 0;
    }
}

/* 6.清除链队中的所有元素 */
void clearQueue(struct queueLK *hq)
{
    struct sNode *p = hq->front;        /* 队首指针赋给p */
    /* 依次删除队列中的每一个结点，最后使队首指针为空 */
    while(p != NULL){
        hq->front = hq->front->next;
        free(p);
        p = hq->front;
    }    /* 循环结束后队首指针已经为空 */
    hq->rear = NULL;        /* 置队尾指针为空 */
    return;
}

/************************************************************************/

int main(int argc, char* argv[])
{
    struct queueLK q;
    int a[8] = {3, 8, 5, 17, 9, 30, 15, 22};
    int i;
    initQueue(&q);
    for(i = 0; i < 8; i++){
        enQueue(&q, a[i]);
    }
    printf("%d ", outQueue(&q));    printf("%d  ", outQueue(&q));
    enQueue(&q, 68);
    printf("%d ", peekQueue(&q));    printf("%d  ", outQueue(&q));
    while(!emptyQueue(&q)){
        printf("%d ", outQueue(&q));
    }
    printf(" ");
    clearQueue(&q);
    system("pause");
}
#include <stdio.h>
#include <stdlib.h>

typedef int elemType;
/************************************************************************/
/*                      以下是关于队列顺序存储操作的6种算法               */
/************************************************************************/

struct queue{
    elemType *queue;        /* 指向存储队列的数组空间 */
    int front, rear, len;    /* 队首指针（下标），队尾指针（下标），队列长度变量 */
    int maxSize;            /* queue数组长度 */
};

void againMalloc(struct queue *q)
{
    /* 空间扩展为原来的2倍，原内容被自动拷贝到p所指向的存储空间中 */
    elemType *p;
    p = realloc(q->queue, 2 * q->maxSize * sizeof(elemType));
    /* 动态存储空间分配，若失败则退出运行 */
    if(!p){
        printf("空间分配失败！ ");
        exit(1);
    }
    q->queue = p;        /* 使queue指向新的队列空间 */
    /* 把原队列的尾部内容后移maxSize个位置 */
    if(q->rear != q->maxSize -1){
        int i;
        for(i = 0; i <= q->rear; i++){
            q->queue[i+q->maxSize] = q->queue[i];
        }
        q->rear += q->maxSize;        /* 队尾指针后移maxSize个位置 */
    }
    q->maxSize = 2 * q->maxSize;    /* 把队列空间大小修改为新的长度 */
    return;
}

/* 1.初始化队列 */
void initQueue(struct queue *q, int ms)
{
    /* 检查ms是否有效，若无效则退出运行 */
    if(ms <= 0){
        printf("ms值非法! ");
        exit(1);
    }
    q->maxSize = ms;        /* 置队列空间大小为ms */
    /* 动态存储空间分配，若失败则退出运行 */
    q->queue = malloc(ms * sizeof(elemType));
    if(!q->queue){
        printf("内存空间分配失败！ ");
        exit(1);
    }
    q->front = q->rear = 0;        /* 初始置队列为空 */
    return;
}

/* 2.向队列中插入元素x */
void enQueue(struct queue *q, elemType x)
{
    /* 当队列满时进行动态生分配 */
    if((q->rear + 1) % q->maxSize == q->front){
        againMalloc(q);
    }
    q->rear = (q->rear + 1) % q->maxSize;        /* 求出队尾的下一个位置 */
    q->queue[q->rear] = x;                        /* 把x的值赋给新的队尾 */
    return;
}

/* 3.从队列中删除元素并返回 */
elemType outQueue(struct queue *q)
{
    /* 若队列为空则终止运行 */
    if(q->front == q->rear){
        printf("队列为空，无法删除！ ");
        exit(1);
    }
    q->front = (q->front +1) % q->maxSize;        /* 使队首指针指向下一个位置 */
    return q->queue[q->front];                    /* 返回队首元素 */
}

/* 4.读取队首元素，不改变队列状态 */
elemType peekQueue(struct queue *q)
{
    /* 若队列为空则终止运行 */
    if(q->front == q->rear){
        printf("队列为空，无法删除！ ");
        exit(1);
    }
    return q->queue[(q->front +1) % q->maxSize];/* 队首元素是队首指针的下一个位置中的元素 */
}

/* 5.检查一个队列是否为空，若是则返回1,否则返回0 */
int emptyQueue(struct queue *q)
{
    if(q->front == q->rear){
        return 1;
    }else{
        return 0;
    }
}

/* 6.清除一个队列，并释放动态存储空间 */
void clearQueue(struct queue *q)
{
    if(q->queue != NULL){
        free(q->queue);
        q->queue = NULL;            /* 设置队列空间指针为空 */
        q->front = q->rear = 0;        /* 设置队列为空 */
        q->maxSize = 0;                /* 设置队列大小为0 */
    }
    return;
}

/************************************************************************/

int main(int argc, char* argv[])
{
    struct queue q;
    int a[8] = {3, 8, 5, 17, 9, 30, 15, 22};
    int i;
    initQueue(&q, 5);
    for(i = 0; i < 8; i++){
        enQueue(&q, a[i]);
    }
    printf("%d ", outQueue(&q));    printf("%d  ", outQueue(&q));
    enQueue(&q, 68);
    printf("%d ", peekQueue(&q));    printf("%d  ", outQueue(&q));
    while(!emptyQueue(&q)){
        printf("%d ", outQueue(&q));
    }
    printf(" ");
    clearQueue(&q);
    system("pause");
    return 0;
}
 
realduke2000
关注
数据结构(C语言描述)读书笔记之队列
一片孤城万仞山
08-16 602
队列简称队，它也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。我们把进行插入的一端称为队尾，进行删除的一端称为队首。我们又把队列称为先进先出表。       一，队列的顺序存储:      struct QueueSq{           ElemType *queue;           int front,rear,len;         
C语言/数据结构——队列的实现
最新发布
yiqingaa的博客
05-18 901
今天我们来聊一聊数据结构的一部分——队列。今天我们主要涉及队列的基本概念结构，以及队列的基本实现。
C语言 队列（循环队列）
qq_42605411的博客
12-30 1450
队列（循环队列） 队列是只允许在一端进行插入操作，在另一端进行删除操作的线性表。允许插入的一端称为队尾，允许删除的一端称为队头。 特性：先进先出。 循环队列 队空：front==rear 队满：rear+1==front 所以需要浪费一个数组空间，例如：6个数组长度的队列，只能存放5个元素。 入队示意图 出队示意图 代码： #include "stdafx.h" const int QUEUESIZE = 6; typedef int ElemType; ElemType data[QUEUESIZE]
c实现队列的基本操作
热门推荐
yuyantai1234的专栏
02-07 2万+
个人根据网上的一些例子，学习自己敲下的代码。 c实现队列的基本操作 #include #include typedef int elemType; /**************************/ /* */ /**************************/ typedef struct nodet { elemType data; st
数据结构之循环队列操作
何文斌的专栏
11-11 990
#include typedef int ElemType; typedef int STATUS; #define MAXSIZE 5 #define OK 1 #define ERROR 0 typedef struct{ int data[MAXSIZE]; int front; int rear; }Sequeue; //循环队列初始化 void InitSequeue(Sequeu
数据结构C语言实现系列[4]——队列.pdf
11-25
数据结构C语言实现系列之队列 数据结构是计算机科学中的一门重要学科，研究的是如何存储、组织和操作数据，以达到高效、可靠和可扩展的目标。队列是数据结构中的一种重要类型，广泛应用于计算机科学和信息技术领域...
数据结构(C语言版)——链队列(代码版)
09-25
### C语言中的链队列实现 在C语言中，链队列的节点通常定义为一个结构体，包括数据域和指针域： ```c typedef struct Node { int data; // 数据域，这里假设是整型数据 struct Node* next; // 指针域，指向下一个...
数据结构——队列 求队列长度 C语言
03-16
输入若干个整数, 以0结束, 利用入队的操作生成一个循环队列, 求该队列的长度。
数据结构(C语言版)——循环顺序队列(代码版)
09-24
数据结构(C语言版)——循环顺序队列(代码版)里面包含C文件和exe文件。基本操作为:1:初始化循环顺序队列2:销毁循环顺序队列3:清空循环顺序队列4:循环顺序队列是否为空5:返回循环顺序队列头元素6:元素入队7:元素出队8:...
顺序队列及运算实现
Learn as if you were to live forever
01-27 1182
队列的顺序存储结构实现称作顺序队列。与顺序表一样，顺序队列也是用一维数组来存储其数据元素的。由于队列中数据元素的变化，其队头和队尾位置也随之变化，故需要设两个指针分别指向当前的队头和队尾位置；为了方便运算，通常约定队尾指针rear指向当前队尾元素的实际位置，而队头指针front指向当前队头元素实际位置的前一个位置。 顺序队列的类型定义如下： typedef struct { ele
数据结构（C语言）之——链队列
weixin_44623055的博客
04-12 1536
#include<stdio.h> #include<stdlib.h> #include<string.h> typedef char ElemType; //定义元素类型 typedef struct LinkNode { //链队列结点 ElemType elem; struct LinkNode *next; }LinkNode; typedef struct LinkQueue { LinkNode *front, *rear; //链队列的队首.
栈和队列 C语言实现
WTF
11-28 9611
本文包括栈的顺序链接存储操作和队的顺序链接存储操作，全部c语言实现，具体程序分析 1、栈的概念 2、栈的顺序存储 示意图： 下面通过一个实例展示栈的顺序存储结构的操作实现，其中包含了6种操作： #include #include typedef int ElemType; //定义元素类型 struct StackSq //定义栈
【数据结构】如何建立先序二叉树
weixin_44274319的博客
11-28 1251
1.考虑直接输入建立二叉树发现无法判定何时输入结束放弃 2.查看大佬代码发现大佬使用队列本来不准备用准备数组直接上发现似乎这样子不能一次性直接建立一个完整的二叉树，大佬果然是大佬 3.改C用C++引用太好用了我要去C++ #include <cstdio> #include <cstdlib> #include <cstring> #define Max 10...
rear和length表示的循环队列
Sunnyyang Pastebin
04-03 1657
problem rear和length表示的循环队列 时限：1000ms 内存限制：10000K 总时限：3000ms 描述： 假设将循环队列定义为：以与变量rear和length分别指示循环队列中队尾元素的位置和内含元素的个数。试给出此循环队列的队满条件，并写出相应的入队列和出队列的算法（在出队列的算法中要返回队头元素）。 输入： 先输入一个不大于100的正整数n（输入数据个数）和m（循环队列数...
数据结构——循环队列【c语言版】
clear-ninghongkang的博客
11-21 2199
队列（quque）简称队，只允许在表的一端输入，在表的另一端删除(操作受限制的线性表)， 把进行插入的一段叫做队尾（表尾），把进入删除的一端叫做队首或队头（表头）。 队列最主要的特点：先进先出，FIFO（first in first out） 队列有其实有三种：顺序队列、循环队列、链式队列 为了避免顺序队列中出现的假溢出现象，我们只需要把数组的前后端连接起来，形成一个环形数组，在逻辑上把这个环称为环形队列或者循环队列。 下面是循环队列的实现过程： ...
队列2
chengfangang的专栏
05-21 969
#include stdio.h> #include stdlib.h> typedef int elemType; /************************************************************************/ /*                    以下是关于队列链接存储操作的6种算法               */ /
C语言数据结构之队列详细解析
Feeryman_Lee的博客
08-30 897
1.队列的顺序存储及其操作（入队出队） 2.队列的链式存储及其操作 3.双端队列以及受限的双端队列
数据结构笔记（三）
ziyu_one的博客
01-26 423
  数据结构——栈和队列 1、第三章：栈和队列 通过下面的思维导图来依次分享「栈和队列」里面重要知识点的笔记。   2、第一节：栈 1.  栈的定义： 栈(stack)：只允许在一端进行插入或删除操作的线性表。 栈顶(Top)：线性表允许进行插入和删除的那一端。 栈底(Bottom)： 固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈的操作特性：后进...
数据结构C语言版讲义——侯筱婷教授
通过这个课程，学习者可以深入理解数据结构的概念，学会如何选择合适的数据结构和算法来解决实际问题，并且能够用C语言实现这些数据结构和算法，这对于提升编程能力和解决实际问题的能力至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值