队列的基本操作

最新推荐文章于 2023-12-18 14:23:15 发布
最新推荐文章于 2023-12-18 14:23:15 发布
阅读量546 收藏
点赞数
分类专栏： 数据结构 文章标签： 队列 指针 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49638344/article/details/119807914
版权

队列Queue

概念

  • 队列也是一种线性表，是一种先进先出的线性结构（FIFO）。队列只允许在表的一端进行插入（入队）、删除（出队）操作。

  • 允许插入的一端称为队尾，允许删除的一端称为队头。
    在这里插入图片描述

队列的基本操作

  • 入队EnterQueue：在队列的队尾插入一个元素
  • 出队DeleteQueue：将队列的队头元素出队
  • 判空IsEmpty：判断队列是否有元素存在
  • 判满IsFull：判断队列是否已满
  • front：返回队头元素

数组实现队列

顺序队列

  • 一开始令front和rear等于-1，表示队空。入队第一个元素时front和rear都赋值为0，然后每入队一个元素rear+1，每出队一个元素front+1，当front等于rear时队空两个整数重新赋值为-1。

在这里插入图片描述在这里插入图片描述

  • 代码：
#include <stdio.h>
#define MAX_SIZE 8//定义队列的最大空间

struct queue
{
    int front; //索引队头
    int rear; //索引队尾
    int data[MAX_SIZE];  //存放队列元素的数组
};

int IsEmpty(struct queue *p)//判空
{
    if (p->front == -1 && p->rear == -1)
    {
        return 0;
    }

    else
    {
        return 1;
    }
}

int IsFull(struct queue *p) //判满
{
    if (p->rear == MAX_SIZE - 1)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

int EnterQueue(struct queue *p, int num) //入队
{
    if (!IsFull(p))
    {
        printf("队列已满\n");
        return 0;
    }
    else if (!IsEmpty(p))//入队第一个元素
    {
        p->front = 0;
        p->rear = 0;
    }
    else
    {
        p->rear++;
    }
    p->data[p->rear] = num;
}

int DeleteQueue(struct queue *p) //出队
{

    if (!IsEmpty(p))
    {
        printf("队列已空\n");
        return 0;
    }
    else if (p->front == p->rear)
    {
        p->rear = -1;
        p->front = -1;
        return 0;
    }
    else
    {
        p->front++;
    }
}

void front(struct queue *p) //打印队首元素
{
    printf("队首元素：%d\n", p->data[p->front]);
}

void printQ(struct queue *p) //打印队列
{
    printf("\n^front|\n");
    int i = p->front;
    while (i <= p->rear)
    {
        printf("%d\n", p->data[i++]);
    }
    printf("^rear|\n");
}

int main()
{
    int i = 0;
    struct queue q = {-1, -1, 0};
    for (i = 0; i < 10; i++)
    {
        EnterQueue(&q, 2 * i + 1);
    }
    printQ(&q);

    DeleteQueue(&q);
    DeleteQueue(&q);
    printQ(&q);

    return 0;
}
  • 终端显示：
队列已满
队列已满

^front|
1
3
5
7
9
11
13
15
^rear|

^front|
5
7
9
11
13
15
^rear|

循环队列

  • 虽然上述的功能实现了，但是有一个很大的问题。因为入队时rear只往后走，出队时front也是往后走，当rear走到数组末尾时就停下了，而front前面的空间就浪费了，这种现象被称为假溢出
    在这里插入图片描述

  • 为了解决这个问题我们可以构造出来一个逻辑上环形的数组，当front和rear走到数组末尾后会从数组头开始再往后走。要实现也不难，只需要front和rear在++的时候先+1再对数组的最大值取余就行了。
    在这里插入图片描述

  • 代码：

#include <stdio.h>
#define MAX_SIZE 8

struct queue
{
    int front;
    int rear;
    int n; //方便起见定义队列内元素个数
    int data[MAX_SIZE];
};

int IsEmpty(struct queue *p)
{
    if (p->front == -1 && p->rear == -1)
    {
        return 0;
    }

    else
    {
        return 1;
    }
}

int IsFull(struct queue *p)
{
    int i = p->rear;//不要动rear，赋值给i去判断
    if ((i + 1) % MAX_SIZE == p->front) //rear和front头尾相连的情况
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

int EnterQueue(struct queue *p, int num)
{

    if (!IsFull(p))
    {
        printf("队列已满\n");
        return 0;
    }
    else if (!IsEmpty(p))
    {
        p->front = 0;
        p->rear = 0;
    }
    else
    {
        p->rear = (p->rear + 1) % MAX_SIZE;
    }
    p->data[p->rear] = num;
    p->n++; //元素数量+1
}

int DeleteQueue(struct queue *p)
{

    if (!IsEmpty(p))
    {
        printf("队列已空\n");
        return 0;
    }
    else if (p->front == p->rear)
    {
        p->rear = -1;
        p->front = -1;
        p->n = 0; //元素数量置零
        return 0;
    }
    else
    {
        p->front = (p->front + 1) % MAX_SIZE;
        p->n--; //元素数量-1
    }
}

void front(struct queue *p)
{
    printf("队首元素：%d\n", p->data[p->front]);
}

int printQ(struct queue *p)
{
    printf("\n^front|\n");
    int i = p->front;
    if (p->n == 0)
    {
        printf("队列已空\n");
        return 0;
    }
    else if (i <= p->rear)
    {
        while (i < p->rear)
        {
            printf("%d\n", p->data[i]);
            i++;
        }
    }
    else  //队尾在数组前面的情况
    {
        for (int j = 0; j < p->n; j++)
        {
            printf("%d\n", p->data[i]);
            i = (i + 1) % MAX_SIZE;
        }
    }

    printf("^rear|\n");
}

int main()
{
    int i = 0;
    struct queue q = {-1, -1, 0, 0};
    for (i = 0; i < MAX_SIZE+2; i++)  //把队列排满，就是这么大气
    {
        EnterQueue(&q, i + 1);
    }
    printQ(&q);

    DeleteQueue(&q);  //出队三个元素
    DeleteQueue(&q);
    DeleteQueue(&q);
    printQ(&q);

    EnterQueue(&q, 666);  //再进来两个
    EnterQueue(&q, 233);
    printQ(&q);

    return 0;
}
  • 终端显示
队列已满
队列已满

^front|
1
2
3
4
5
6
7
8
^rear|

^front|
4
5
6
7
8
^rear|

^front|
4
5
6
7
8
666
233
^rear|

链表实现队列

  • 定义两个指针分别指向队头和队尾，队头即链表头。入队时使用队尾指针把新节点给尾节点的next，指针后移；出队时队头指针后移的同时释放头节点。

在这里插入图片描述

  • 代码：
#include <stdio.h>
#include <stdlib.h>

struct node //定义节点
{
    int data;
    struct node *next;
};

struct queue  //定义队列
{
    struct node *front;
    struct node *rear;
    int num; //节点数
    int size;  //定义队列大小
};

int IsEmpty(struct queue *p)
{
    if (p->front == NULL && p->rear == NULL)
    {
        return 0;
    }

    else
    {
        return 1;
    }
}

int IsFull(struct queue *p)
{
    if (p->num == p->size)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

int EnterQueue(struct queue *p)
{
    if (!IsFull(p))
    {
        printf("队列已满\n");
        return 0;
    }
    else if (!IsEmpty(p))
    {
        p->rear = (struct node *)malloc(sizeof(struct node));
        p->front = p->rear;
        p->rear->next = NULL;
        p->num++;
        printf("请输入第1个节点数据：\n");
        scanf("%d", &(p->rear->data));
        return 0;
    }
    else
    {
        p->rear->next = (struct node *)malloc(sizeof(struct node));
        p->rear->next->next = NULL;
        p->rear = p->rear->next;
        p->num++;
        printf("请输入第%d个节点数据：\n", p->num);
        scanf("%d", &(p->rear->data));
        return 0;
    }
}

int DeleteQueue(struct queue *p)
{
    if (!IsEmpty(p))
    {
        printf("队列已空\n");
        return 0;
    }
    else if (p->front == p->rear) //只有一个节点的情况
    {
        free(p->rear);
        p->rear = NULL;
        p->front = NULL;
        p->num = 0; //元素数量置零
        return 0;
    }
    else
    {
        struct node *temp = p->front;
        p->front = p->front->next;
        free(temp);
        p->num--; //元素数量-1
        return 0;
    }
}

int front(struct node *front)
{
    if (!IsEmpty)
    {
        printf("队列已空\n");
        return 0;
    }
    printf("队首元素：%d\n", front->data);
}

int printQ(struct node *front) //遍历链表，打印数据
{
    printf("\nfront:< ");
    if (!IsEmpty)
    {
        printf("队列已空\n");
        return 0;
    }
    while (front)
    {
        printf("%d ", front->data);
        front = front->next;
    }
    printf("<rear\n");
}

int main()
{
    int i = 0;
    struct queue q = {NULL, NULL, 0, 8};

    printf("请输入要入队的元素个数，最多入队%d个\n", q.size);
    scanf("%d", &i);
    while (i--)
    {
        EnterQueue(&q);
    }
    printQ(q.front);

    front(q.front);

    DeleteQueue(&q);
    DeleteQueue(&q);

    printQ(q.front);

    return 0;
}
  • 终端显示：
请输入要入队的元素个数，最多入队8个
9
请输入第1个节点数据：
111
请输入第2个节点数据：
222
请输入第3个节点数据：
333
请输入第4个节点数据：
444
请输入第5个节点数据：
555
请输入第6个节点数据：
666666
请输入第7个节点数据：
777
请输入第8个节点数据：
888
队列已满

front:< 111 222 333 444 555 666666 777 888 <rear
队首元素：111

front:< 333 444 555 666666 777 888 <rear

再见！ ❤️

money的大雨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
链式队列的基本操作（详细）
qq_43346784的博客
07-08 7770
队列的基本操作（）链式 ，详细
队列及其基本操作
hmh520i的博客
03-23 854
队列及其基本操作
数据结构-队列的相关操作
qq_62023949的博客
01-09 670
数据结构-队列的相关操作（链式队列、循环队列）
数据结构队列的基本操作
qq_46636024的博客
12-08 1429
栈是限定仅在表尾进行插入或删除操作的线性表。表尾端称为栈顶，表头端称为栈底，不含元素的空表称为空栈。假设栈S=(a1,a2,…an),则称a1为栈底元素，an为栈顶元素。退栈的第一个元素应为栈顶元素。栈的修改是按后进先出的原则进行的，因此，栈又称为后进先出的线性表。队列是一种先进先出的线性表，它只允许在表的一端进行插入，而在另一端删除元素。允许插入的一端为队尾，允许删除的一端为队头。
队列基本操作
11-14
数据结构队列的操作，包括 建立空队列，队列的插入，队列的删除，以及输出队列，打印在屏幕上，一目了然哦……
实验二 堆栈和队列基本操作的编程实现
02-09
堆栈和队列基本操作的编程实现 要求： 堆栈和队列基本操作的编程实现（2学时，验证型），掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现，存储结构可以在顺序结构或链接结构中任选，也可以全部...
数据结构实验报告2-栈与队列-队列基本操作算法-实验内容及要求.docx
07-06
编写程序，建立容量为n(建议n=8)的循环队列，完成以下程序功能。输入字符#，执行一次出队操作，屏幕上显示出队字符；输入字符@，队列中所有字符依次出队并按出队次序在屏幕上显示各字符；输入其它字符，则输入的字符...
队列的基本操作_队列的基本操作_
10-01
在这个程序中，我们将深入探讨队列的基本操作，这些操作通常包括初始化、入队、出队、查看队首元素和判断队列是否为空。 1. **初始化队列**： 初始化队列通常是创建一个空队列，可以使用数组或链表来实现。在数组...
队列的操作
08-18
#include<stdio.h> #include<stdlib.h> #define ElemType int #define Q (*qe) struct quenode { ElemType data; struct quenode *next;
【数据结构】队列的基本操作
Jesonary的博客
04-13 2664
编写程序，实现链式、循环队列的基本操作。
数据结构系列－队列的基本操作
热门推荐
lin20080410的专栏
03-19 7万+
队列(Queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。允许插入的端是队尾，允许删除的端是队头。所以说队列是一个先进先出的线性表，相应的也有顺序存储和链式存储两种方式。顺序存储就是用数组实现，比如有一个ｎ个元素的队列，数组下标0的一端是队头，入队操作就是通过数组下标一个个顺序追加，不需要移动元素，但是如果删除队头元素，后面的元素就要往前移动，对应的时间复杂度就是O(n)，性能...
数据结构：图文详解 队列 | 循环队列 的各种操作（出队，入队，获取队列元素，判断队列状态）
最新发布
luming的博客
12-18 1万+
队列（Queue）是一种数据结构，是一种先进先出（First-In-First-Out，FIFO）的线性数据结构。它只允许在列表的一端进行插入操作（入队），在另一端进行删除操作（出队），即队头进行删除操作，队尾进行插入操作。队列常用的操作有入队（Enqueue）、出队（Dequeue）、获取队头元素（Front/Peek）、获取队列长度（Size/Length）等。 队列的特点是按照元素加入的先后顺序进行操作，先加入队列的元素会先被取出，后加入的元素会后被取出。 循环队列解决了普通队列的一些缺点，如空间浪费
队列的基本操作（顺序队列，循环队列，链队列）
So_cute_SJM的博客
01-17 2890
一. 定义： 和栈相反，队列是一种“先进先出”的线性表。即它只能在表的一端进行插入，在表的另一端删除元素。 在队列中，允许插入的一段叫做队尾，允许删除的一端则称为队头。 队列的插入操作称为进队，删除操作称为出队。 新插入的元素只能添加到队尾，被删除的元素只能是排在队头的元素。 二. 队列的顺序表示和实现： (一) . 顺序队列： 队列的顺序存储结构简称为“顺序队列”，它是由一个一维数...
循环队列基本操作实现
10-23
以下是循环队列基本操作的实现方法： 1. 初始化：创建一个空的循环队列，需要指定队列的最大长度。 2. 入队：将元素插入到队列的队尾，如果队列已满则无法插入。 3. 出队：将队列的队头元素删除并返回，如果队...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

money的大雨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值