C语言实现顺序队列、循环队列、链式队列

已于 2022-06-16 16:38:36 修改
阅读量2.5k 收藏 37
点赞数 4
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： c语言 链表 数据结构
于 2019-04-13 19:02:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42250302/article/details/89285894
本文深入探讨了三种队列数据结构：顺序队列、循环队列和链式队列。详细介绍了每种队列的实现原理，包括初始化、入队、出队、判空和判满等关键操作。并通过实例演示了队列的基本操作流程。

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

文章目录

队列：先进先出（FIFO）。队尾入队，队头出队。

1 顺序队列

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

#define MAXSIZE 100
typedef int dataType;

typedef struct {
    dataType data[MAXSIZE];
    int front; //指向队列中第一个元素
    int rear;  //指向队列中最后一个元素下一位置
} SeQueue;

SeQueue* initSeQueue();             //创建一个空循环队列
int push(SeQueue* Q, dataType x);   //将元素x入队。操作成功返回1，失败返回0
int pop(SeQueue* Q, dataType* x);   //队首元素出队，并将其值赋给x。操作成功返回1，失败返回0
int isEmpty(SeQueue* Q);            //队列空返回1，否则返回0
int isFull(SeQueue* Q);             //队列满返回1，否则返回0
int getSize(SeQueue* Q);            //返回队列中存储的元素个数
int front(SeQueue* Q, dataType* x); //取队首元素，并将其值赋给x。操作成功返回1，失败返回0
int back(SeQueue* Q, dataType* x);  //取队尾元素，并将其值赋给x。操作成功返回1，失败返回0

int main()
{
    SeQueue* sq;
    int i;
    dataType x;

    sq = initSeQueue();
    int len = 10;

    printf("入队:\n");
    for (i = 0; i < len; i++) {
        push(sq, i);
        printf("%d 入队，队列长度为 %d\n", i, getSize(sq));
    }

    printf("\n出队:\n");
    for (i = 0; i < len; i++) {
        pop(sq, &x);
        printf("%d 出队，剩余队列长度为 %d\n", x, getSize(sq));
    }

    return 0;
}
// 建立空队列
SeQueue* initSeQueue()
{
    SeQueue* Q = (SeQueue*)malloc(sizeof(SeQueue));
    Q->front = 0;
    Q->rear = 0;

    return Q;
}

// 返回队列长度
int getSize(SeQueue* Q)
{
    return Q->rear - Q->front;
}

// 队列空返回1，否则返回0
int isEmpty(SeQueue* Q)
{
    return getSize(Q) == 0 ? 1 : 0;
}

// 队列满返回1，否则返回0
int isFull(SeQueue* Q)
{
    return getSize(Q) == MAXSIZE ? 1 : 0;
}

// 入队
int push(SeQueue* Q, dataType x)
{
    if (isFull(Q)) {
        return 0;
    } else {
        Q->data[Q->rear] = x;
        Q->rear++;
        return 1;
    }
}

// 出队
int pop(SeQueue* Q, dataType* x)
{
    if (isEmpty(Q)) {
        return 0;
    } else {
        *x = Q->data[Q->front];
        Q->front++;
        return 1;
    }
}

//取队首元素，并将其值赋给x。操作成功返回1，失败返回0
int front(SeQueue* Q, dataType* x)
{
    if (isEmpty(Q)) {
        return 0;
    } else {
        *x = Q->data[Q->front];
        return 1;
    }
}
//取队尾元素，并将其值赋给x。操作成功返回1，失败返回0
int back(SeQueue* Q, dataType* x)
{
    if (isEmpty(Q)) {
        return 0;
    } else {
        *x = Q->data[Q->rear - 1];
        return 1;
    }
}


C:\WINDOWS\system32\cmd.exe /c (gcc -fexec-charset=gbk 1.c -o 1 ^&^& 1 ^&^& del 1.exe)
入队:
0 入队，队列长度为 1
1 入队，队列长度为 2
2 入队，队列长度为 3
3 入队，队列长度为 4
4 入队，队列长度为 5
5 入队，队列长度为 6
6 入队，队列长度为 7
7 入队，队列长度为 8
8 入队，队列长度为 9
9 入队，队列长度为 10

出队:
0 出队，剩余队列长度为 9
1 出队，剩余队列长度为 8
2 出队，剩余队列长度为 7
3 出队，剩余队列长度为 6
4 出队，剩余队列长度为 5
5 出队，剩余队列长度为 4
6 出队，剩余队列长度为 3
7 出队，剩余队列长度为 2
8 出队，剩余队列长度为 1
9 出队，剩余队列长度为 0
Hit any key to close this window...

2 循环队列

1、队列：随着入队出队的进行，rear、front后移，当指针移到最后，出现假溢出，浪费存储空间
2、循环队列：通过循环移动指针，解决假溢出

设循环队列首尾指针分别为front、rear，队列容量（队列可容纳的最大元素个数，不是实际存储的元素个数）为 capacity

2.1 循环队列判满、判空

2.1.1 设置计数器num

1、num == 0，循环队列空
2、num == capacity，循环队列满

2.1.2 少用一元素空间

1、front == rear，循环队列空
2、(rear + 1) % capacity == front，循环队列满

下面使用第二种方法判满、判空方法实现代码。

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

#define CQ_INIT_SIZE 100 //队列初始容量
typedef int dataType;

typedef struct {
    dataType* data; //存储队列元素
    int front;      //指向队列中第一个元素
    int rear;       //指向队列中最后一个元素下一位置
    int cqCapacity; //最多能容纳的元素个数(队列容量)
} CQueue;

CQueue* initCQueue();              //创建一个空循环队列
int push(CQueue* Q, dataType x);   //将元素x入队。操作成功返回1，失败返回0
int pop(CQueue* Q, dataType* x);   //队首元素出队，并将其值赋给x。操作成功返回1，失败返回0
int front(CQueue* Q, dataType* x); //取队首元素，并将其值赋给x。操作成功返回1，失败返回0
int back(CQueue* Q, dataType* x);  //取队尾元素，并将其值赋给x。操作成功返回1，失败返回0
int isEmpty(CQueue* Q);            //队列空返回1，否则返回0
int isFull(CQueue* Q);             //队列满返回1，否则返回0
int getSize(CQueue* Q);            //返回队列中存储的元素个数

int main()
{
    CQueue* cq;
    int i;
    dataType x;

    cq = initCQueue();
    int n = 10;

    printf("入队:\n");
    for (i = 0; i < n; i++) {
        push(cq, i);
        printf("%d 入队，队列长度为 %d，", i, getSize(cq));

        if (back(cq, &x)) {
            printf("队尾元素为 %d\n", x);
        }
    }

    printf("\n出队:\n");
    for (i = 0; i < n; i++) {
        pop(cq, &x);
        printf("%d 出队，剩余队列长度为 %d，", x, getSize(cq));

        if (front(cq, &x)) {
            printf("队首元素为 %d\n", x);
        }
    }

    return 0;
}

// 建立空队列
CQueue* initCQueue()
{
    CQueue* Q = (CQueue*)malloc(sizeof(CQueue));
    Q->data = (dataType*)malloc(CQ_INIT_SIZE * sizeof(dataType));
    Q->front = 0;
    Q->rear = 0;
    Q->cqCapacity = CQ_INIT_SIZE;

    return Q;
}

int getSize(CQueue* Q)
{
    return (Q->rear - Q->front + Q->cqCapacity) % Q->cqCapacity;
}

int isFull(CQueue* Q)
{
    return (Q->rear + 1) % Q->cqCapacity == Q->front ? 1 : 0;
}

int isEmpty(CQueue* Q)
{
    return Q->front == Q->rear ? 1 : 0;
    // return getSize(Q) == 0 ? 1 : 0;
}

// 入队
int push(CQueue* Q, dataType x)
{
    if (isFull(Q)) {
        // 若达到最大容量，则将新容量扩大至旧容量 1.5 倍
        int increment = Q->cqCapacity / 2;
        Q->data = (dataType*)realloc(Q->data,
            (Q->cqCapacity + increment) * sizeof(dataType));

        if (!Q->data) {
            return 0;
        }
        Q->cqCapacity += increment;
    }
    Q->data[Q->rear] = x;
    Q->rear = (Q->rear + 1) % Q->cqCapacity;
    return 1;
}

// 出队
int pop(CQueue* Q, dataType* x)
{
    if (isEmpty(Q)) {
        return 0;
    } else {
        *x = Q->data[Q->front];
        Q->front = (Q->front + 1) % Q->cqCapacity;
        return 1;
    }
}
//取队首元素，并将其值赋给x。操作成功返回1，失败返回0
int front(CQueue* Q, dataType* x)
{
    if (isEmpty(Q)) {
        return 0;
    } else {
        *x = Q->data[Q->front];
        return 1;
    }
}
//取队尾元素，并将其值赋给x。操作成功返回1，失败返回0
int back(CQueue* Q, dataType* x)
{
    if (isEmpty(Q)) {
        return 0;
    } else {
        *x = Q->data[Q->rear - 1];
        return 1;
    }
}


C:\Windows\system32\cmd.exe /c (gcc -fexec-charset=gbk 1.c -o 1 ^&^& 1 ^&^& del 1.exe)
入队:
0 入队，队列长度为 1，队尾元素为 0
1 入队，队列长度为 2，队尾元素为 1
2 入队，队列长度为 3，队尾元素为 2
3 入队，队列长度为 4，队尾元素为 3
4 入队，队列长度为 5，队尾元素为 4
5 入队，队列长度为 6，队尾元素为 5
6 入队，队列长度为 7，队尾元素为 6
7 入队，队列长度为 8，队尾元素为 7
8 入队，队列长度为 9，队尾元素为 8
9 入队，队列长度为 10，队尾元素为 9

出队:
0 出队，剩余队列长度为 9，队首元素为 1
1 出队，剩余队列长度为 8，队首元素为 2
2 出队，剩余队列长度为 7，队首元素为 3
3 出队，剩余队列长度为 6，队首元素为 4
4 出队，剩余队列长度为 5，队首元素为 5
5 出队，剩余队列长度为 4，队首元素为 6
6 出队，剩余队列长度为 3，队首元素为 7
7 出队，剩余队列长度为 2，队首元素为 8
8 出队，剩余队列长度为 1，队首元素为 9
9 出队，剩余队列长度为 0，Hit any key to close this window...

3 链式队列

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

// nil == 2147483647
#define nil 0x7fffffff

typedef int dataType;
typedef struct node {
    dataType data;
    struct node* next;
} QNode;

typedef struct {
    QNode* front;
    QNode* rear;
} LQueue;

LQueue* initLQueue();               // 建立空队列
int length(LQueue* Q);              // 返回队列长度
int isEmpty(LQueue* Q);             // 队列为空返回1；否则返回0
int inQueue(LQueue* Q, dataType x); // 入队成功返回1
int outQueue(LQueue* Q);            // 出队成功返回出队元素；否则返回 nil(0x7fffffff)
void traverseLQueue(LQueue* Q);     // 遍历链队列并输出
void destroyLQueue(LQueue* Q);      // 销毁队列

int main()
{
    LQueue* lq;
    int i;

    lq = initLQueue();
    int len = 10;

    printf("入队：\n");
    for (i = 0; i < len; i++) {
        inQueue(lq, i);
    }
    printf("队列长度：%d\n", length(lq));
    traverseLQueue(lq);

    printf("\n出队：\n");
    for (i = 0; i < len; i++) {
        int x = outQueue(lq);
        printf("%d 出队，剩余队列长度为 %d\n", x, length(lq));
    }
    traverseLQueue(lq);

    printf("\n销毁队列\n");
    destroyLQueue(lq);

    return 0;
}

// 建立空队列
LQueue* initLQueue()
{
    LQueue* Q;
    QNode* head; // head为头节点，队列空时front、rear都指向head

    Q = (LQueue*)malloc(sizeof(LQueue));
    head = (QNode*)malloc(sizeof(QNode));
    head->next = NULL;
    Q->front = head;
    Q->rear = head;

    return Q;
}

// 返回队列长度。也可用队列头节点存储队列长度，这样只需 return Q->front->data，
// 在入队、出队操作加上Q->front->data++、Q->front->data--。可以省去遍历的时间开销。
int length(LQueue* Q)
{
    int len = 0;
    QNode* p = Q->front;

    // while(p != Q->rear)
    while (p->next) {
        len++;
        p = p->next;
    }

    return len;
}

int isEmpty(LQueue* Q)
{
    return Q->front == Q->rear ? 1 : 0;
}

// 入队
int inQueue(LQueue* Q, dataType x)
{
    QNode* p;

    p = (QNode*)malloc(sizeof(QNode));
    p->data = x;
    p->next = NULL;
    Q->rear->next = p;
    Q->rear = p;
    return 1;
}

// 出队。出队成功返回出队元素，否则返回 nil(0x7fffffff)
int outQueue(LQueue* Q)
{
    if (isEmpty(Q)) {
        return nil;
    } else {
        QNode* p;
        dataType element;

        // 首元素出队并释放内存
        p = Q->front->next;
        Q->front->next = p->next;
        element = p->data;
        free(p);

        if (Q->front->next == NULL) {
            Q->rear = Q->front;
        }
        return element;
    }
}

// 遍历链队列
void traverseLQueue(LQueue* Q)
{
    if (isEmpty(Q) == 1) {
        printf("队列为空！\n");
    } else {
        QNode* p;
        int c;

        printf("队中元素依次为：");
        p = Q->front;
        while (p->next) {
            printf("%d, ", p->next->data);
            p = p->next;
        }
        printf("\n");
    }
}

// 销毁队列
void destroyLQueue(LQueue* Q)
{
    QNode* p = Q->front->next;
    while (p) {
        Q->front->next = p->next;
        free(p);
        p = Q->front->next;
    }
    free(Q->front);
    free(Q);
    Q = NULL;
    printf("销毁成功！\n");
}

C:\WINDOWS\system32\cmd.exe /c (gcc -fexec-charset=gbk 1.c -o 1 ^&^& 1 ^&^& del 1.exe)
入队：
队列长度：10
队中元素依次为：0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

出队：
0 出队，剩余队列长度为 9
1 出队，剩余队列长度为 8
2 出队，剩余队列长度为 7
3 出队，剩余队列长度为 6
4 出队，剩余队列长度为 5
5 出队，剩余队列长度为 4
6 出队，剩余队列长度为 3
7 出队，剩余队列长度为 2
8 出队，剩余队列长度为 1
9 出队，剩余队列长度为 0
队列为空！

销毁队列
销毁成功！
Hit any key to close this window...
循环队列的链式实现（C语言）
SalamAbdu的博客
07-15 530
任务要求： 1.创建循环队列 2.链式实现 3.设置一个标志域tag,用它来判断front和rear相等时的队列情况。默认tag=0表示队列“空” 3.写出队列初始化，入队，出队函数 #include <iostream> #include <stdlib.h> #include <stdio.h> using namespace std; typedef int ElemType; typedef struct LinkNode { ElemType data
循环队列+链式队列（C语言）
GR_001的博客
04-18 606
今天也要努力学习，争取考上杭电！ 队列的知识 队列也是一种受限的线性表！！！只允许在表的一端进行插入，另一端进行删除（双端队列后面说）。 队头（Front）：允许删除的一端 队尾（Rear）：允许插入的一端 队列的特性：先进先出（First In First Out , FIFO） 双端队列：允许两端都可以进行入队出队操作的队列。依然是线性结构！！！ 输出受限的双端队列：允许一端进行插入和删除，但...
c语言简单的循环链队列,队列（循环，链式）C语言
weixin_39775577的博客
05-23 315
一、链表结构的队列#include"stdlib.h"#include"stdlio.h"typedef struct QNode{int data;struct QNode *next;}QNode,*QueuePrt;typedef struct{QueuePrt front, rear;}LinkQueue;int InitQueue(LinkQueue *LQ){LQ->front ...
C语言数据结构——队列
最新发布
2301_77766416的博客
06-24 419
队列是一种基**先进先出(FIFO)**的数据结构，是一种只能在一端进行插入,在另一端进行删除操作的特殊线性表，它按照先进先出的原则存储数据，先进入的数据，在读取数据时先读被读出来。2、队列的应用举例1：排队系统的实现举例2：使用循环队列存储网络摄像头的数据帧（图像数据）3、队列的具体实现顺序队列链队列。
C语言-队列（链式队列，循环队列）
m0_63223213的博客
07-06 2195
循环队列和链式队列详解及相关测试
c语言中如何写一循环链表队列,C语言数据结构——线性表链式循环队列(链表实现方式)...
weixin_26833939的博客
05-21 475
队列相关知识及操作请参看上一章一、链式队列链式队列 ： 用链表形式实现的队列。链表结点为队列数据存储区，链表结点包括两部分数据存储区和指针存储区。数据存储区 ：存放真实有效数据的区域。指针存储区 ：存放下一个链表结点的地址。注意：1. 链式队列不存在队列已满的情况。在内存足够大的情况下，每次动态申请链表结点内存都会成功，即不会出现队列已满的情况，除非数据量超大内存不够。2. 链式队列只存在队列为空...
C语言实现队列源码，包含顺序队列，链式队列，循环队列，亲测可用
04-25
本文将详细讨论在C语言中实现的几种队列类型，包括顺序队列、链式队列以及循环队列，并结合提供的源代码进行解析。 顺序队列是基于数组实现的数据结构，它的特点是操作主要集中在数组的两端：一端称为队头，用于出...
C语言中的队列（顺序队列与链式队列）——概念及其基本操作
热门推荐
qq_51308373的博客
03-21 1万+
前言 太久没更新了，早就说要写结果拖到现在。闲话说完，正式开始内容。 队列——顾名思义，其实在线性表中也是一种极其重要的结构。 与栈不同的是，栈对元素的插入和删除均在一端进行，而队列，从队头删除，队尾插入，正如日常生活中的排队一样，还是比较形象的。 本文将对队列的概念及操作函数进行简要介绍，并说明顺序队列（利用数组）和链式队列（利用链表）的一些基本算法。 一、队列的相关概念 1.队列及其操作 （先进先出） 1.1 相关概念 （1）队列：只允许在表的一端删除元素，在另一端插入元素的线性表 （2）空队列：不含元
C语言实现循环队列及基本操作
weixin_45227693的博客
04-05 1004
现代系统设计中，队列衍生出多种增强形态。其核心特性是元素的插入（入队）发生在队尾（Rear），而删除（出队）则从队头（Front）进行，类似于现实生活中的排队场景（如售票窗口）。这些演进形式突破传统队列的局限性，在保持顺序处理核心特征的同时，通过结构创新满足不同场景的特定需求。该实现完整展示了循环队列的核心特性，通过模运算实现高效的环形缓冲区操作，适合需要固定大小队列的场景。在计算机系统中，队列常用于管理需要按序处理的任务，例如操作系统的进程调度、消息队列的异步通信，以及广度优先搜索（BFS）算法。
c语言建立队列（顺序队列、循化队列和链式队列）
qq_39838607的博客
09-07 3543
c语言建立队列 一、顺序队列 队列的顺序存储结构 顺序队列的讨论 "下溢"现象 "真上溢"现象 "假上溢"现象 二、如何解决"假上溢"问题 三、循环队列 循环队列说明 循环队列的实现方法 1、设置一个标记以区别队列是空还是满 2、使用一个计数器记录队列中元素的总数 3、保留对空条件，修改队满条件（常用） 循化队列的存储结构定义 初始化队列 设置标志 入队操作 出队操作 设置计数器方法 入队操作 出队操作 方法三 入队操作 出队操作 其余操作 四、链式队列 说明 链式存储结构 入队操作 出队操作 其余操作
C语言实现顺序队列：入队、出队操作详解
"这篇教程详细介绍了队列的顺序存储结构，并以C语言作为实现语言，讲解了队列的基本操作和算法描述。" 队列是一种特殊类型的线性数据结构，遵循“先进先出”（FIFO）的原则，即最早被添加到队列中的元素将最先被...
c语言链式栈或循环队列，实现插入，删除数据，能演示过程
10-15
c语言链式栈或循环队列，实现插入，删除数据，能演示过程，输出结果
C语言实现的顺序队列
01-20
C语言实现的顺序队列
链式循环队列实现（C语言）
wutiankesiyry1的博客
10-09 532
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
C语言用循环链表表示队列
qq_41829337的博客
08-13 518
C语言用循环链表表示队列
链式队列 || 循环队列--C语言实现
weixin_45506125的博客
07-15 418
链式队列的思想是尾插法，先进先出。 1、首先我们需要一个头节点 //创建一个结构体表示节点 typedef struct node_s { int data; struct node_s* next; }que; //创建头节点 que* creat_head_node() { que* head = (que*)malloc(sizeof(que)); head->next = NULL; memset(head, 0, sizeof(que)); r
C语言《数据结构》———顺序队列
qq_59931372的博客
04-18 1254
用十分钟带你学会c语言《数据结构》中的顺序队列
实现顺序队列(c代码)
weixin_43962818的博客
01-08 232
#include <stdio.h> #include <stdbool.h> #include <stdlib.h> typedef int q_t; typedef struct { q_t in; q_t out; q_t *data; q_t mxlen; }queue_t; /create a queue and init/ queue_t * create_queue(int len){ queue_t q = (queue_t)malloc(sizeof(q
C语言数据结构代码——顺序队列
qq_41862220的博客
04-27 523
Head.H typedef struct _seqque { int *front; int *rear; int qsize; }SeqQue, *seqque; seqque InitSeqQueue(int qsize); void EnQueue(seqque Q, int num); int DeQueue(seqque Q); void PrintSeqQueue(seq...
C语言队列实现源码全解：顺序、链式、循环队列示例
顺序队列通过数组实现，链式队列通过链表实现，而循环队列则是在顺序队列的基础上优化而来，解决了数组队列存在的空间浪费问题。文章《也没想象中那么神秘的数据结构-先来后到的“队列”》提供了对队列概念的介绍和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值