队列练习之Example006-设计队列要求入队时增加队列空间，出队后出队元素所占用空间可重复使用，以保持队列空间只增不减，并且要求入队操作和出队操作的时间复杂度都为O(1)

最新推荐文章于 2023-09-09 22:21:54 发布
最新推荐文章于 2023-09-09 22:21:54 发布
阅读量1.9k 收藏 47
点赞数 11
分类专栏： 数据结构 文章标签： 数据结构 队列 链队 循环单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/124677745
版权

Example006

题目

请设计一个队列，要求满足：

  • ①初始时队列为空；
  • ②入队时，允许增加队列占用空间；
  • ③出队后，出队元素所占用的空间可重复使用，即整个队列所占用的空间只增不减；
  • ④入队操作和出队操作的时间复杂度始终保持为O(1)。

请回答下列问题：

  • 1）该队列是应选择链式存储结构，还是应选择顺序存储结构?
  • 2）画出队列的初始状态，并给出判断队空和队满的条件。
  • 3）画出第一个元素入队后的队列状态。
  • 4）给出入队操作和出队操作的基本过程。

分析

本题很难，毕竟是 408 统考真题，也没有要求写代码。但如果通过画图那么还是很容易理解到如何出队和入队的。题解如下：

1）该队列是应选择链式存储结构，还是应选择顺序存储结构?

  • 要求①很容易满足，因为初始化队列都是空的；
  • 对于要求②，可以使用链式存储，每次入队新元素时便创建新结点并分配空间，这样也增加了队列空间。而顺序存储空间是一开始就分配好的，队列的占用空间无法随着入队操作而增加，所以需要选择链式存储结构。
  • 对于要求③，要求出队元素的空间可以重复使用，即即使链队结点出队后，也不要释放空间，以前的链表删除操作都会释放掉被删结点的空间。我们可以这样操作：对出队后的结点不真正释放（即不调用 free 函数释放空间），而是用队头指针指向新的队头结点，原队头结点仍然保留在链式队列中，但队头指针却不指向它了；而有新元素入队时，有空余结点则无需创建新结点开辟新空间，直接赋值到队尾后的第一个空结点即可，然后用队尾指针指向新的队尾结点。这就要求设计成一个首尾相接的循环单链表，即链式循环队列。
  • 对于要求④，由于有队头指针和队尾指针，所以链式循环队列的入队操作和出队操作的时间复杂度都是 O(1)。

2）画出队列的初始状态，并给出判断队空和队满的条件。

该链式循环队列的实现可以参考顺序循环队列，不同之处在于链式循环队列可以动态地增加空间，出队的结点也可以循环利用，入队时空间不够也可以动态增加。同样，链式循环队列，也需要区分队满和队空的情况，这里参考顺序循环队列牺牲一个单元来判断，即在链式循环队列中有一个结点是不存储任何数据的，仅用来判断链式循环队列是队满还是队空。初始化时，创建一个只有空闲结点（初始时就必须有这个空闲结点，用来判断队空和队满的空闲结点）循环单链表，队头指针 front 和队尾指针 rear 均指向空闲结点，如图所示：

在这里插入图片描述

  • 队空的判定条件：queue->front==queue->rear。
  • 队满的判定条件：queue->front==queue->rear->next。

注：

  • 初始时，无论是队空的判定还是队满的判定条件都能通过，所以初始时既是队空也是队满。
  • 链式循环队列不存在队满的。由于在出队后，结点空间不会释放掉，所以会一直存在，那么队满的判定条件就会返回 0，表示可以直接利用空余结点来存储新元素。如果再入队，那么就会把空余结点也给用完，那时候就存在队满了，即没有空余结点就是队满状态。如果只是一直入队那么一直都是队满状态。
  • 上图只是初始化图，是不太容易看得出到底是队空还是队满的，可以看看下图：

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

3）画出第一个元素入队后的队列状态。

插入第一个元素后的状态如图所示：

在这里插入图片描述

注：有些书上是将新结点放在空闲结点（即图中的紫色结点）前面，我在这里面踩了一些坑，这样的做法是很不容易插入新结点的，代码不太好写，所以不推荐。如下图所示：

在这里插入图片描述

4）给出入队操作和出队操作的基本过程。

如果是3）中第一张图的作法，那么操作的基本过程如下：

// 入队操作
if(queue->front==queue->rear->next) {// 队满
    创建新结点 newNode 并为其分配空间;
    newNode->next=queue->rear->next;
    queue->rear->next=newNode;
    queue->rear=newNode;
} else {// 队未满
    queue->rear=queue->rear->next;
    queue->rear->data=ele;
}

// 出队操作
if(queue->front==queue->rear) {// 队空
    则出队失败，返回;
} else {// 队非空
    queue->front=queue->front->next;
    ele=queue->front->data;
}

如果是3）中第二张图的作法，那么操作的基本过程如下：

// 入队操作
if(queue->front==queue->rear->next) //队满
    则在 rear 后面插入一个新的空闲结点;
入队元素保存到 rear 所指结点中;
queue->rear=queue->rear->next;
返回;

// 出队操作
if(queue->front==queue->rear) //队空
    则出队失败然后返回;
取 front 所指结点中的元素 ele;
queue->front=queue->front->next;
返回 ele;

注：如果是3）中第一张图的作法，则入队多个元素后如图所示：

在这里插入图片描述

注：如果是3）中第二张图的作法，则入队多个元素后如图所示：

在这里插入图片描述

注：之所以要指出这种区别，是为了不陷入某些参考书中，选择自己能理解的解法即可。本题后面采用的是3）中第一张图的做法。

图解

  • 初始化链式循环队列

在这里插入图片描述

  • 队满与队未满状态

在这里插入图片描述

  • 队空与队非空

在这里插入图片描述

  • 入队（在队已满情况下）

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

  • 出队

在这里插入图片描述

在这里插入图片描述

  • 入队（在队未满情况下）

在这里插入图片描述

在这里插入图片描述

C实现

核心代码：

/**
 * 将元素入队
 * @param queue 链队列
 * @param ele 待入队的元素
 */
void enQueue(LinkedQueue **queue, int ele) {
    // 如果链式队列已满，则创建新结点进行插入
    if (isFull(*queue)) {
        // 创建新结点
        QNode *newNode = (QNode *) malloc(sizeof(QNode));
        newNode->data = ele;
        newNode->next = NULL;
        // 将新结点插入
        newNode->next = (*queue)->rear->next;
        (*queue)->rear->next = newNode;
        (*queue)->rear = newNode;
    }
        // 如果链式队列未满，则直接利用已有结点的空间，而不必创建新结点
    else {
        (*queue)->rear = (*queue)->rear->next;
        (*queue)->rear->data = ele;
    }
}

/**
 * 将元素出队
 * @param queue 链队列
 * @param ele 用来保存出队元素
 * @return 如果链队列为空则不能出队则返回 0 表示出队失败；否则返回 1 表示出队成功
 */
int deQueue(LinkedQueue **queue, int *ele) {
    if (isEmpty(*queue)) {
        return 0;
    } else {
        (*queue)->front = (*queue)->front->next;
        *ele = (*queue)->front->data;
        return 1;
    }
}

完整代码：

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

/**
 * 链队列中的结点结构体定义
 */
typedef struct QNode {
    /**
     * 结点数据域，存储链队列中结点的数据
     */
    int data;
    /**
     * 结点指针域，存储当前结点的后继结点的地址
     */
    struct QNode *next;
} QNode;

/**
 * 链队列结构体定义
 */
typedef struct {
    /**
     * 存储链队列的队头结点的地址，即指向队头结点
     */
    QNode *front;
    /**
     * 存储链队列的队尾结点的地址，即指向队尾结点
     */
    QNode *rear;
} LinkedQueue;

/**
 * 初始化链队列
 * @param queue 未初始化的链队列
 */
void init(LinkedQueue **queue) {
    // 其实 queue 就相当于链队列的头结点，不过它有两个指针，分别存储队头结点和队尾结点的地址
    // 为链队列头结点分配存储空间
    *queue = (LinkedQueue *) malloc(sizeof(LinkedQueue));
    // 将队头指针和队尾指针都指向 NULL，表示空队列
    (*queue)->front = NULL;
    (*queue)->rear = NULL;
    // 创建一个结点用于来判断链式循环队列是否队满或队空
    QNode *node = (QNode *) malloc(sizeof(QNode));
    node->next = node;
    // 将队列的 front 和 rear 都指向 node 结点
    (*queue)->front = node;
    (*queue)->rear = node;
}

/**
 * 判断链队列是否为空
 * @param queue 链队列
 * @return 如果链队列为空则返回 1，否则返回 0 表示非空
 */
int isEmpty(LinkedQueue *queue) {
    if (queue->front == queue->rear) {
        return 1;
    } else {
        return 0;
    }
}

/**
 * 判断链队列是否已满
 * @param queue 链队列
 * @return 如果队满则返回 1，否则返回 0
 */
int isFull(LinkedQueue *queue) {
    if (queue->front == queue->rear->next) {
        return 1;
    } else {
        return 0;
    }
}

/**
 * 将元素入队
 * @param queue 链队列
 * @param ele 待入队的元素
 */
void enQueue(LinkedQueue **queue, int ele) {
    // 如果链式队列已满，则创建新结点进行插入
    if (isFull(*queue)) {
        // 创建新结点
        QNode *newNode = (QNode *) malloc(sizeof(QNode));
        newNode->data = ele;
        newNode->next = NULL;
        // 将新结点插入
        newNode->next = (*queue)->rear->next;
        (*queue)->rear->next = newNode;
        (*queue)->rear = newNode;
    }
        // 如果链式队列未满，则直接利用已有结点的空间，而不必创建新结点
    else {
        (*queue)->rear = (*queue)->rear->next;
        (*queue)->rear->data = ele;
    }
}

/**
 * 将元素出队
 * @param queue 链队列
 * @param ele 用来保存出队元素
 * @return 如果链队列为空则不能出队则返回 0 表示出队失败；否则返回 1 表示出队成功
 */
int deQueue(LinkedQueue **queue, int *ele) {
    if (isEmpty(*queue)) {
        return 0;
    } else {
        (*queue)->front = (*queue)->front->next;
        *ele = (*queue)->front->data;
        return 1;
    }
}

/**
 * 获取链队列中的结点个数
 * @param queue 链队列
 * @return 结点个数
 */
int size(LinkedQueue *queue) {
    // 变量，记录链队列结点个数
    int len = 0;
    // 变量，结点链队列的队头结点，相当于单链表的开始结点
    QNode *node = queue->front->next;
    // 扫描链队列，即遍历单链表，统计结点个数
    while (node != queue->front) {
        len++;
        node = node->next;
    }
    return len;
}

/**
 * 获取链队列的队头结点数据值
 * @param queue 链队列
 * @param ele 用来保存队头结点数据值
 * @return 如果链队列为空则返回 0 表示获取失败，否则返回 1 表示获取成功
 */
int getFront(LinkedQueue *queue, int *ele) {
    // 0.参数校验，如果链队列为空，则表示不能获取队头元素
    if (isEmpty(queue)) {
        return 0;
    }
    // 1.用 ele 保存队头结点的数据值，即队头指针所指向的后继结点的数据域
    *ele = queue->front->next->data;
    return 1;
}

/**
 * 获取链队列的队尾结点数据值
 * @param queue 链队列
 * @param ele 用来保存队尾结点数据值
 * @return 如果链队列为空则返回 0 表示获取失败，否则返回 1 表示获取成功
 */
int getRear(LinkedQueue *queue, int *ele) {
    // 0.参数校验，如果链队列为空，则表示不能获取队尾元素
    if (isEmpty(queue)) {
        return 0;
    }
    // 1.用 ele 保存队尾结点的数据值，即队尾指针所指向的结点
    *ele = queue->rear->data;
    return 1;
}

/**
 * 打印链队列的所有结点值
 * @param queue 链队列
 */
void print(LinkedQueue *queue) {
    printf("[");
    QNode *frontNode = queue->front;
    QNode *node = frontNode->next;
    // 对于队满和队非满两种情况
    if (isFull(queue)) {
        while (node != frontNode) {
            printf("%d", node->data);
            if (node->next != frontNode) {
                printf(", ");
            }
            node = node->next;
        }
    } else {
        while (node != queue->rear) {
            printf("%d", node->data);
            if (node->next != queue->rear) {
                printf(", ");
            }
            node = node->next;
        }
        printf(", %d", queue->rear->data);
    }
    printf("]\n");
}


int main() {
    // 声明链队列
    LinkedQueue *queue;

    // 初始化链队列
    printf("\n初始化链队列：\n");
    init(&queue);
    print(queue);

    // 队列是否为空
    printf("\n队列是否为空：\n");
    int empty;
    empty = isEmpty(queue);
    printf("%d\n", empty);

    // 将元素入队
    printf("\n将元素入队：\n");
    enQueue(&queue, 11);
    print(queue);
    enQueue(&queue, 22);
    print(queue);
    enQueue(&queue, 33);
    print(queue);
    enQueue(&queue, 44);
    print(queue);

    // 队列是否已满
    printf("\n队列是否已满：\n");
    int full;
    full = isFull(queue);
    printf("%d\n", full);

    // 将元素出队
    printf("\n将元素出队：\n");
    int ele;
    deQueue(&queue, &ele);
    printf("出队元素：%d\n", ele);
    print(queue);
    deQueue(&queue, &ele);
    printf("出队元素：%d\n", ele);
    print(queue);

    // 队列是否已满
    printf("\n队列是否已满：\n");
    full = isFull(queue);
    printf("%d\n", full);

    // 再将元素入队
    printf("\n将元素入队：\n");
    enQueue(&queue, 55);
    print(queue);
    enQueue(&queue, 66);
    print(queue);

    // 队列是否已满
    printf("\n队列是否已满：\n");
    full = isFull(queue);
    printf("%d\n", full);

    // 队头元素
    printf("\n队头元素：\n");
    int front;
    getFront(queue, &front);
    printf("%d\n", front);

    // 队尾元素
    printf("\n队尾元素：\n");
    int rear;
    getRear(queue, &rear);
    printf("%d\n", rear);

    // 队列元素个数
    printf("\n队列元素个数：\n");
    int len;
    len = size(queue);
    printf("%d\n", len);
}

执行结果：

初始化链队列：
[]

队列是否为空：
1

将元素入队：
[11]
[11, 22]
[11, 22, 33]
[11, 22, 33, 44]

队列是否已满：
1

将元素出队：
出队元素：11
[22, 33, 44]
出队元素：22
[33, 44]

队列是否已满：
0

将元素入队：
[33, 44, 55]
[33, 44, 55, 66]

队列是否已满：
1

队头元素：
33

队尾元素：
66

队列元素个数：
4

Java实现

略。

二木成林
关注
  • 11
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#队列的操作实例
11-13
首先，队列的基本操作包括添加元素（入队）和移除元素（出队）。在C#中，我们可以利用System.Collections命名空间下的Queue类来实现队列。创建一个队列实例后，可以通过Enqueue方法添加元素到队尾，通过Dequeue方法...
请设计一个队列，要求满足：①初始时队列为空；②入队时，允许增加队列占用空间；③出队后，出队元素所占用的空间可重复使用，即整个队列所占用的空间只增不减；④入队操作和出队操作的时间复杂度始终保持为O（1）
qq_64296768的博客
08-26 592
请设计一个队列，要求满足：①初始时队列为空；②入队时，允许增加队列占用空间；③出队后，出队元素所占用的空间可重复使用，即整个队列所占用的空间只增不减；④入队操作和出队操作的时间复杂度始终保持为O(1)
王道第三章3.2.5-二-04【2019统考真题】请设计一个队列,要求满足...思路详解
m0_58108607的博客
02-14 1246
4 【2019统考真题】请设计一个队列,要求满足: 初始时队列为空; ②入队时,允许增加队列占用空间; ③出队后,出队元素所占用的空间可重复使用,即整个队列所占用的空间只增不减;④入队操作和出队操作的时间复杂度始终保持为O(1)。请回答下列问题: 1)该队列是应选择链式存储结构,还是应选择顺序存储结构? 2)画出队列的初始状态,并给出判断队空和队满的条件。 3)画出第一个元素入队后的队列状态。 4)给出入队操作和出队操作的基本过程。 我的思路： 刚开始考虑的是 双向链表 队列的队头front是链表的尾指
循环单链表创建队列
qq_61706112的博客
09-14 321
/*请设计一个队列,要求满足:1.初始时队列为空;2.入队时,允许增加队列占用空间;3.出队后,出队元素所占用的 空间可重复使用,即整个队列所占用的空间值增不减;4.入队操作和出队操作的时间复杂度始终保持为O(1)*/ //想法：与顺序循环存储队列相似 #include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct LNode{ ElemType data; struct LNode *next.
2019年链式队列大题
发现问题，并解决问题，批判性思维
08-18 2502
【知识回顾】 【真题】 请设计一个队列，满足： （1）初始时队列为空；（2）入队时，允许增加队列占用空间； （3）出队后，出队元素所占用的空间可重复使用，即整个队列所占用的空间只增不减； （4）入队操作和出队操作的时间负责度始终保持为O（1）。 第一问：选链式/顺序存储结构 顺序存储无法满足（2）的“队列占用空间随着入队而增加”，（1）容易满足； 链式存储方便开辟新空间，要求（2）容易满足； 要求（3）出队后的结点并不真正释放，用队头指针指向新的队头结点，新元素入队时，有空余结点则无.
4, 【2019统考真题】请设计一个队列,要求满足: D初始时队列为空； ②入队时,允许增加 队列占用空间； ③出队后,出队元素所占用的空间可重复使用,即整个队列所占用的空间 只增不减；④入队操作和出
Anthony_4926
07-08 3913
4, 【2019统考真题】请设计一个队列,要求满足: 初始时队列为空; ②入队时,允许增加队列占用空间; ③出队后,出队元素所占用的空间可重复使用,即整个队列所占用的空间只增不减;④入队操作和出队操作的时间复杂度始终保持为O(1)。请回答下列问题: 1)该队列是应选择链式存储结构,还是应选择顺序存储结构? 2)画出队列的初始状态,并给出判断队空和队满的条件。 3)画出第一个元素入队后的队列状态。 4)给出入队操作和出队操作的基本过程。 1）队列应选择链式存储结构。如果用顺序存储，当队列满时，无法做到入队
数据结构-队列(Queue)介绍和Java示例代码
07-01
队列是一种重要的线性数据结构，它遵循先进先出（FIFO）的规则，即最先插入的元素将最先被移除。在计算机科学中，队列广泛应用于各种算法和程序设计中，尤其在处理需要顺序处理任务的场景下。在Java中，队列可以借助...
java 栈和队列的小例子
03-29
在Java编程语言中，栈（Stack）和队列（Queue）是两种基本的数据结构，它们在处理数据存储和操作方面有着广泛的应用。本教程将通过一些小例子来深入理解这两种数据结构及其在Java中的实现。 栈是一种后进先出（LIFO...
C#队列的实现
11-24
队列的主要操作包括：入队（enqueue）、出队（dequeue）、检查头部元素（Peek）以及检查队列是否为空（Count或IsEmpty）。 在C#中，我们可以使用System.Collections.Queue类来创建和操作队列。以下是一些基本的使用...
php-resque
08-17
在Web开发中，队列处理是一种常见的策略，用于将耗时的任务（如邮件发送、数据处理或分析）从主应用程序流程中分离出来，以提高响应速度和用户体验。`php-resque` 正是这样的工具，它使用 Redis 作为持久化存储，...
2019年计算机考研统考（408）真题与参考答案（清晰扫描版）.pdf
08-07
2019年计算机考研统考（408）真题与参考答案（清晰扫描版）
队列-链队和顺序队的简单操作
Li_Lei1的博客
12-04 1674
队列学习笔记–链队和顺序队 1.队列（循环队列） 在队列的顺序存储结构中，除了用一组地址连续的存储单元依次存放从队列头到队列尾的元素之外，尚需附设两个整型变最 front 和 rear分别指示队列头元素及队列尾元素的位置（后面分别称为头指针和尾指针）。 每当插入新的队列尾元素时，尾指针 rear增1; 每当删除队列头元素时， 头指针 front增1。因此，在非空队列中，头指针始终指向队列头元素，而尾指针始终指向队列尾元素的下一个位置。 循环队列可充分利用空间，且减少了时间复杂度，通过移动frong和rear
数据结构选择练习题（有解析）
沉在海里的鱼的博客
12-23 1万+
目录 前言 选择题与答案与解析 实验1 线性表 实验2 栈和队列 实验3 二叉树 实验4 二叉搜索树与平衡二叉树 实验5 散列查找 实验6 图的存储与遍历 实验7 最小生成树 实验8 快速排序与归并排序 结语 前言 已经到期末了，昨天进行了一次马原考试，那时候挺紧张的，那时候虽然写完了试卷，但是又4道题是乱写的，因为我刚好没有背，希望不会挂科吧。 然后今天呢，就开始复习数据结构了，然后发现数据结构这学期进行的8次实验的选择题竟然...
【队列】队头指针队尾指针指向类题目总结
热门推荐
无
02-21 1万+
引入 众说周知，在队列的题目中，队头指针(front)和队尾指针(rear)有两种指示方法。 （1）队头指针 ①指向队头元素 ②指向队头元素元素的前一个位置 （2）队尾指针 ①指向队尾元素 ②指向队尾元素的后一个位置 指示方法不同元素入队和出队操作也不同，但是在做大部分题目的时候，我们并不需要分析队头指针和队尾指针具体操作，我们只要记住下面两个结论就行 结论 结论一：当队列执行元素入队操作时，队尾指针（rear）向后移，队头指针（front）不变 结论二：当队列执行元素出队操作时，队头指针（front）向后
队列
忘之苡巛
08-02 460
循环队列 #include<stdio.h> #define MaxSize 100 typedef int ElemType; typedef struct { ElemType data[MaxSize]; int front, rear; }SqQueue; //初始化队列 void InitQueue(SqQueue& Q) { Q.rear = Q.front = 0; } //判队列空 bool QueueEmpty(SqQueue Q) { return Q.
数据结构-----队列
Poison__的博客
07-21 2210
数据结构之队列 数据结构的学习笔记，不妥之处请指正。 文章目录数据结构之队列前言一、先入先出的数据结构1、先入先出的数据结构2、队列的实现3、循环队列4、设计循环队列二、队列和广度优先搜索参考 前言 在数组中，可以通过索引访问 随机 元素。 但是某些情况下，可能需要限制处理的顺序。 下面我们将学习第一个 先入先出（FIFO） 的处理顺序，也就是队列。 一、先入先出的数据结构 1、先入先出的数据结构 在队列中，第一个进入的元素就是第一个被处理的元素（先进先出）。 队列有头有尾，我们平常所说的插
王道数据结构编程题 栈和队列
最新发布
qq_37409526的博客
09-09 228
假设 I 和 O 分别表示入栈和出栈操作，栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅由 I 和 O 组成的序列，可以操作的序列称为合法序列，否则称为非法序列。编写一个算法，判定所给的序列是否合法。若合法，返回 true，否则返回 false.
队列概念及基础操作（附练习题）
weixin_52920836的博客
11-07 498
队列 队列的顺序存储 1.队列的定义：队列是一种操作受到限制的线性表，它只允许在队列的一段进行插入操作，而在另一端进行删除操作。（就如同在排队一般，先排队的人员先进行办理业务）---即先进先出。 队列示意图： 2.队列的数据结构定义： define Maxsize 50 typedef struct{ Elemtype data[Maxsize]; //存放队列元素 int front,rear; //队头指针与队尾指针 }SqQ...
队列相关习题
＃两个西柚
08-07 2520
1.已知循环队列存储在一维数组A0…n-1]中，且队列非空时front和rear分别指向队头元素和队尾元素。若初始时队列为空，且要求第一个进入队列的元素存储在A[0]处，则初始时front和rear的值分别是( )。 A.0，0 B. 0，n-1 C. n-1, 0 D. n-1，n-1 2.循环队列存储在数组A[0…n]中，入队时的操作为( )。 A. rear=rear+1 B. rear= (rear+1) mod (n-1) C. rear= (rear+1) mod n D. rear= (rea
队列子系统 1------入队 2------出队 3------显示队列中元素0------返回
04-03
代码示例： ```python class Queue: def __init__(self): self.items = [] def enqueue(self, item): self.items.append(item) def dequeue(self): if not self.is_empty(): return self.items.pop(0) def is_empty(self): return len(self.items) == 0 def size(self): return len(self.items) def display(self): print(self.items) if __name__ == '__main__': q = Queue() while True: print("1------入队") print("2------出队") print("3------显示队列中元素") print("0------返回") choice = int(input("请输入你的选择：")) if choice == 1: item = input("请输入要入队的元素：") q.enqueue(item) elif choice == 2: item = q.dequeue() if item: print("出队元素为：", item) else: print("队列已空") elif choice == 3: q.display() elif choice == 0: break else: print("输入有误，请重新输入！") ``` 运行结果： ``` 1------入队 2------出队 3------显示队列中元素 0------返回 请输入你的选择：1 请输入要入队的元素：a 1------入队 2------出队 3------显示队列中元素 0------返回 请输入你的选择：1 请输入要入队的元素：b 1------入队 2------出队 3------显示队列中元素 0------返回 请输入你的选择：3 ['a', 'b'] 1------入队 2------出队 3------显示队列中元素 0------返回 请输入你的选择：2 出队元素为： a 1------入队 2------出队 3------显示队列中元素 0------返回 请输入你的选择：3 ['b'] 1------入队 2------出队 3------显示队列中元素 0------返回 请输入你的选择：2 出队元素为： b 1------入队 2------出队 3------显示队列中元素 0------返回 请输入你的选择：2 队列已空 1------入队 2------出队 3------显示队列中元素 0------返回 请输入你的选择：0 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值