【王道】数据结构与算法队列Queue(五)

最新推荐文章于 2023-04-14 23:18:18 发布
最新推荐文章于 2023-04-14 23:18:18 发布
阅读量892 收藏 8
点赞数 3
分类专栏： # 数据结构与算法🔥 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Augenstern_QXL/article/details/120978979
版权

✍、目录脑图

在这里插入图片描述

目录

1、队列Queue

线性表是具有相同数据类型的 n(n≥0) 个数据元素的有限序列，其中 n 为表长，当 n = 0时线性表是一个空表。

  • 栈：栈是只允许在一端进行插入(进栈)或删除操作(出栈)的线性表

  • 队列：队列是只允许在一端进行插入(入队)，在另一端删除(出队)的线性表

1.1、队列的重要术语

空队列：队列中没有存储数据元素

队尾：允许插入元素的一端

队头：允许删除元素的一端

在这里插入图片描述

  • 记忆：队列就是食堂排队

  • 队列特点：先进先出 ，First In First Out (FIFO)

在这里插入图片描述

1.2、顺序存储队列的定义

#define MaxSize 10					// 定义队列中元素的最大个数
typedef struct {
    ELemType data[MaxSize];			// 用静态数组存放队列元素
    int front,rear;					// 队头指针和队尾指针
}SqQueue;

1.3、链式存储队列的定义

typedef struct LinkNode {					// 链式队列结点
    ElemType data;
    struct LinkNode *next;
}LinkNode;

typedef struct {							// 链式队列
    LinkNode *front,*rear;					// 队列的队头和队尾指针
}LinkQueue;

2、顺序存储队列实现

顺序存储队列有两种实现方式：

  • 队尾指针指向队尾元素
  • 队尾指针指向队尾元素的下一个

2.1、队尾指针指向队尾元素的下一个

2.1.1、初始化

  • InitQueue(&Q) : 初始化队列，构造一个空队列 Q
#define MaxSize 10					// 定义队列中元素的最大个数
typedef struct {
    ELemType data[MaxSize];			// 用静态数组存放队列元素
    int front,rear;					// 队头指针和队尾指针
}SqQueue;

// 初始化队列
void InitQueue(SqQueue &Q){
    // 初始时,队头、队尾指针指向0
    Q.rear = Q.front = 0;
}
  • 队头指针 front 指向队头元素
  • 队尾指针 rear 指向队尾元素的后一个位置(下一个应该插入的位置)

在这里插入图片描述

2.2.2、判断队列是否为空

  • QueueEmpty(Q) : 判断队列是否为空，若队列Q为空则返回 true，否则返回 false

在这里插入图片描述

// 判断队列是否为空
bool QueueEmpty(SqQueue Q){
    if(Q.rear == Q.front){			// 队空条件
        return true;
    }else{
        return false;
    }
}

2.2.3、入队

  • EnQueue(&Q,x) : 入队，若队列 Q 未满，将 x 加入，使之称为新的队尾

  • 只能从队尾入队

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

所以队尾指针 rear 其实是从队头指向队尾，再从队尾指向队头，这样循环移动。

在这里插入图片描述

这样使用模运算将存储空间在逻辑上变成了 “环状”，我们也称之为循环队列

在这里插入图片描述

#define MaxSize 10					// 定义队列中元素的最大个数
typedef struct {
    ELemType data[MaxSize];			// 用静态数组存放队列元素
    int front,rear;					// 队头指针和队尾指针
}SqQueue;

// 入队
bool EnQueue(SqQueue &Q,ElemeType x){
    if((Q.rear + 1)%MaxSize == Q.front){	// 判断队满
        return false;						// 队满则报错
    }
    Q.data[Q.rear] = x;						// 将 x 插入队尾
    Q.rear = (Q.rear + 1)%MaxSize;			// 队尾指针加1取模,用模运算将存储空间在逻辑上变成了"环状"
    return true;
}

2.2.4、出队

  • DeQueue(&Q,&x) : 出队，若队列 Q 非空，删除队头元素，并用 x 返回
  • 只能从队头出队

在这里插入图片描述

#define MaxSize 10					// 定义队列中元素的最大个数
typedef struct {
    ELemType data[MaxSize];			// 用静态数组存放队列元素
    int front,rear;					// 队头指针和队尾指针
}SqQueue;

// 出队(删除一个队头元素,并用 x 返回)
bool DeQueue(SqQueue &Q,ElemType &x){
    if(Q.rear ==Q.front){					// 判断队空
        return false;						// 队空则报错
    }
    X = Q.data[Q.front];
    Q.front = (Q.front +1)%MaxSize;			// 队头指针后移
    return true;				
}

2.2.5、获得队头元素值

  • GetHead(Q,&x) ：读取队头元素，若队列Q非空，则将队头元素
#define MaxSize 10					// 定义队列中元素的最大个数
typedef struct {
    ELemType data[MaxSize];			// 用静态数组存放队列元素
    int front,rear;					// 队头指针和队尾指针
}SqQueue;

// 获得队头元素的值,用 x 返回
bool GetHead(SqQueue Q,ElemType &x){
    if(Q.rear == Q.front){			// 判断队空
        return false;   			// 队空则报错
    }
    X = Q.data[Q.front];			// 获得队头元素值
    return true;
}

2.2、判断队列已满/已空

我们前面说判断队列满的时候，不得不牺牲一个存储单元，否则就与我们的队空相互矛盾，但是有时候出题老师可不想让我们浪费这一个存储单元，所以判断队列已满/已空有两种方案

  • 方案一：浪费一个存储单元
  • 方案二：不浪费一个存储单元，用一个 size
  • 方案三：不浪费存储单元，用一个 tag 标记

2.2.1、方案一

  • 队列已满的条件：队尾指针的再下一个位置是队头，即 (Q.rear+1)%MaxSize == Q.front

  • 队空的条件是：队尾指针和队头指针指向相同，Q.rear == Q.front

  • 队列元素个数：(rear + MaxSize - front)%MaxSize

在这里插入图片描述

2.2.2、方案二

在这里插入图片描述

在这里插入图片描述

虽然队头和队尾指针都指向了同一位置，但是由于 size 的存在，所以仍然可以判断队列是满的还是空的。

#define MaxSize 10					// 定义队列中元素的最大个数
typedef struct {
    ELemType data[MaxSize];			// 用静态数组存放队列元素
    int front,rear;					// 队头指针和队尾指针
    int size;						// 队列当前长度
}SqQueue;

// 初始化队列
void InitQueue(SqQueue &Q){
    // 初始时,队头、队尾指针指向0
    Q.rear = Q.front = 0;
    // 队列长度也为0
    size = 0;
}

// 入队
bool EnQueue(SqQueue &Q,ElemeType x){
    if(Q.size == MaxSize){					// 判断队满
        return false;						// 队满则报错
    }
    Q.data[Q.rear] = x;						// 将 x 插入队尾
    Q.rear = (Q.rear + 1)%MaxSize;			// 队尾指针加1取模,用模运算将存储空间在逻辑上变成了"环状"
    size++;									// 每一次入队成功我们让队列长度 + 1
    return true;
}


// 出队(删除一个队头元素,并用 x 返回)
bool DeQueue(SqQueue &Q,ElemType &x){
    if(Q.size == 0){						// 判断队空
        return false;						// 队空则报错
    }
    X = Q.data[Q.front];
    Q.front = (Q.front +1)%MaxSize;			// 队头指针后移
    size--;									// 每一次出队成功我们让队列长度 - 1
    return true;				
}

2.2.3、方案三

#define MaxSize 10					// 定义队列中元素的最大个数
typedef struct {
    ELemType data[MaxSize];			// 用静态数组存放队列元素
    int front,rear;					// 队头指针和队尾指针
    int tag;						// 最近进行的是删除(0)/插入(1)
}SqQueue;


// 初始化队列
void InitQueue(SqQueue &Q){
    // 初始时,队头、队尾指针指向0
    Q.rear = Q.front = 0;
    // 标志为0
    tag = 0;
}

// 入队
bool EnQueue(SqQueue &Q,ElemeType x){
    if(Q.front == Q.rear && tag == 1){		// 判断队满,只有插入操作,才可能导致队满
        return false;						// 队满则报错
    }
    Q.data[Q.rear] = x;						// 将 x 插入队尾
    Q.rear = (Q.rear + 1)%MaxSize;			// 队尾指针加1取模,用模运算将存储空间在逻辑上变成了"环状"
    tag == 1;								// 每次插入操作成功时,都令 tag = 1
    return true;
}


// 出队(删除一个队头元素,并用 x 返回)
bool DeQueue(SqQueue &Q,ElemType &x){
    if(Q.front == Q.rear && tag == 0){		// 判断队空,只有删除操作,才可能导致队空
        return false;						// 队空则报错
    }
    X = Q.data[Q.front];
    Q.front = (Q.front +1)%MaxSize;			// 队头指针后移
    tag == 0;								// 每次删除操作成功时,都令 tag = 0
    return true;				
}

2.3、队尾指针指向队尾元素🔥

还有一种出题方法，就是队尾指针 rear 指向的不是队尾元素的下一个，而是队尾元素的位置

在这里插入图片描述

2.3.1、初始化

#define MaxSize 10					// 定义队列中元素的最大个数
typedef struct {
    ELemType data[MaxSize];			// 用静态数组存放队列元素
    int front,rear;					// 队头指针和队尾指针
}SqQueue;

// 初始化队列
void InitQueue(SqQueue &Q){
    // 初始时,队头指针指向0,队尾指针指向 n - 1
    Q.front = 0;
    Q.rear = n - 1
}

在这里插入图片描述

  • 入队操作
#define MaxSize 10					// 定义队列中元素的最大个数
typedef struct {
    ELemType data[MaxSize];			// 用静态数组存放队列元素
    int front,rear;					// 队头指针和队尾指针
}SqQueue;

// 入队
bool EnQueue(SqQueue &Q,ElemeType x){
    if((Q.rear + 1)%MaxSize == Q.front){	// 判断队满
        return false;						// 队满则报错
    }
    Q.rear = (Q.rear + 1)%MaxSize;			// 先将队尾指针向上移一位
    Q.data[Q.rear] = x;						// 再将 x 插入队尾
    
    return true;
}

3、链式存储队列实现

3.1、带头结点

在这里插入图片描述

3.1.1、初始化

初始化时

  • 先申请一个结点，然后让队头指针 front、队尾指针 rear 都指向这个结点
  • 之后让此结点的指针域指向NULL

在这里插入图片描述

typedef struct LinkNode {					// 链式队列结点
    ElemType data;
    struct LinkNode *next;
}LinkNode;

typedef struct {							// 链式队列
    LinkNode *front,*rear;					// 队列的队头和队尾指针
}LinkQueue;

// 初始化队列(带头结点)
void InitQueue(LinkQueue &Q){
    // 初始时, front、rear 都指向头结点
    Q.front = Q.rear = (LinkNode*)malloc(size(LinkNode));
    Q.front->next = NULL;
}

3.1.2、判断队列是否为空

判断队列是否为空，只需要看队头指针和队尾指针是否指向相同，指向相同队列为空，指向不相同队列不为空

// 判断队列是否为空(带头结点)
bool IsEmpty(LinkQueue Q){
    if(Q.front == Q.rear){
        return true;
    }else{
        return false;
    }
}

3.1.3、入队

入队只能在队尾入队

  • 先申请一个结点s
  • 将新入队元素 x 放入这个结点中
  • 将 s 结点的指针域指向 NULL
  • 之后将 s 结点插入到 rear 之后
  • 修改表尾指针为 s 结点
  1. 先申请一个结点s，将新入队元素 x 放入这个结点中

在这里插入图片描述

  1. 将 s 结点的指针域指向 NULL，之后将 s 结点插入到 rear 之后

在这里插入图片描述

  1. 修改表尾指针为 s 结点

在这里插入图片描述

typedef struct LinkNode {					// 链式队列结点
    ElemType data;
    struct LinkNode *next;
}LinkNode;

typedef struct {							// 链式队列
    LinkNode *front,*rear;					// 队列的队头和队尾指针
}LinkQueue;

// 新元素入队(带头结点)
void EnQue(LinkQueue &Q,ElemType x){
    LinkNode *s =(LinkNode *)malloc(sizeof(LinkNode));				// 用 malloc 申请一个新结点
    s->data = x;													// 将 x 放入这个结点中
    s->next = NULL;				// 插入操作在表尾进行,新插入的结点x肯定是在表尾,所以将x结点指针域设为NULL
    Q.rear->next = s;						// 新结点插入到 rear 之后
    Q.rear = s;								// 修改表尾指针
}

3.1.4、出队

带头结点出队只能从队头出队

  • 申请一个新结点 p 指向头结点后面的一个结点(也就是队头结点)，用变量 x 返回队头结点元素
  • 修改头结点的 next 指针，使其指向 p 结点的下一个结点
  • 如果出队的结点是最后一个结点，我们要修改队尾指针，让其指向头结点
  • 释放 p 结点
  1. 申请一个新结点 p 指向头结点后面的一个结点(也就是队头结点)，用变量 x 返回队头结点元素

在这里插入图片描述

  1. 修改头结点的 next 指针

在这里插入图片描述

  1. 如果出队的结点是最后一个结点，我们要修改队尾指针rear，让其指向头结点

在这里插入图片描述

在这里插入图片描述

  1. 释放 p 结点

在这里插入图片描述

typedef struct LinkNode {					// 链式队列结点
    ElemType data;
    struct LinkNode *next;
}LinkNode;

typedef struct {							// 链式队列
    LinkNode *front,*rear;					// 队列的队头和队尾指针
}LinkQueue;


// 队头元素出队(不带头结点)
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front == Q.rear){
        return false;						// 空队
    }
    LinkNode *p = Q.front->next;			// 申请新结点p 指向头结点的后面一个结点
    x = p->data;							// 用变量 x 返回队头元素
    Q.front->next = p->next;				// 修改头结点的 next 指针
    if(Q.rear == p){						// 如果此次是最后一个结点出队
        Q.rear = Q.front;					// 修改 rear 指针
    }		
    free(p);								// 释放结点空间
    return true;
}

3.1.5、队列满的条件

顺序存储-> 预分配的空间耗尽时队满

链式存储-> 一般不会队满，可以扩容，除非内存不足

3.2、不带头结点

在这里插入图片描述

3.2.1、初始化

在这里插入图片描述

typedef struct LinkNode {					// 链式队列结点
    ElemType data;
    struct LinkNode *next;
}LinkNode;

typedef struct {							// 链式队列
    LinkNode *front,*rear;					// 队列的队头和队尾指针
}LinkQueue;

// 初始化队列(不带头结点)
void InitQueue(LinkQueue &Q){
    // 初始时, front、rear 都指向NULL
    Q.front = NULL;
    Q.rear = NULL;
    
}

3.2.2、判断队列是否为空

// 判断队列是否为空(不带头结点)
bool IsEmpty(LinkQueue Q){
    if(Q.front == NULL){
        return true;
    }else{
        return false;
    }
}

3.2.3、入队

不带头结点的队列，第一个元素入队时需要特别处理

  • 先申请一个新结点 s，将新入队元素 x 放入这个结点中，将此结点的 next 指针域 指向 NULL
  • 需要判断如果这个队列为空，那么就意味着新结点 s 是这个队列的第一个结点，需要将 front、rear 都指向这个新结点 s
  • 如果队列不为空，就是执行后插操作了
  1. 先申请一个新结点 s，将新入队元素 x 放入这个结点中，将此结点的 next 指针域 指向 NULL

在这里插入图片描述

  1. 需要判断如果这个队列为空，那么就意味着新结点 s 是这个队列的第一个结点，需要将 front、rear 都指向这个新结点 s

在这里插入图片描述

  1. 如果队列不为空，就是执行后插操作了
typedef struct LinkNode {					// 链式队列结点
    ElemType data;
    struct LinkNode *next;
}LinkNode;

typedef struct {							// 链式队列
    LinkNode *front,*rear;					// 队列的队头和队尾指针
}LinkQueue;

// 新元素入队(不带头结点)
void EnQue(LinkQueue &Q,ElemType x){
    LinkNode *s =(LinkNode *)malloc(sizeof(LinkNode));		// 申请新结点
    s->data = x;											// 向此结点写入数据元素 x
    s->next = NULL;				// 插入操作在表尾进行,新插入的结点x肯定是在表尾,所以将x结点指针域设为NULL
    if(Q.front == NULL){					// 如果队列为空	
        Q.front = s;						// 不带头结点的队列，第一个元素入队时需要特别处理	
        Q.rear = s;							// 在空队列中插入第一个元素,修改队头队尾指针
    }else{
        Q.rear->next = s;						// 新结点插入到 rear 之后
    	Q.rear = s;								// 修改表尾指针
    }
}

3.2.4、出队

不带头结点出队只能从队头出队

  • 首先申请新结点 p 指向此次出队的结点(队头结点)，用变量 x 返回队头元素
  • 修改队头指针 front 指向
  • 如果是最后一个结点出队，需要将 front 、rear 指针指向 NULL(将其恢复为空队的状态)
  • 释放结点 p
  1. 首先申请新结点 p 指向此次出队的结点(队头结点)，用变量 x 返回队头元素

在这里插入图片描述

  1. 修改队头指针 front 指向

在这里插入图片描述

  1. 释放结点 p
// 队头元素出队(不带头结点)
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front == NULL){
        return false;								// 空队
    }
    LinkNode *p = Q.front;							// 申请新结点 p 指向此次出队的结点
    x = p->data;									// 用变量 x 返回队头元素
    Q.front = p->next;								// 修改 front 指针
    if(Q.rear == p){
        Q.front = NULL;								// front 指向 NULL
        Q.rear = NULL;								// rear 指向 NULL
    }
    free(P);										// 释放结点空间
    return true; 
}

3.3、小结

在这里插入图片描述

4、双端队列

栈：只允许从一端插入、一端删除的线性表

队列：只允许从一端插入、另一端删除的线性表

双端队列：只允许从两端插入、两端删除的线性表

在这里插入图片描述

4.1、受限的双端队列

输入受限的双端队列：只允许从一端插入、两端删除的线性表

输出受限的双端队列：只允许从两端插入、一端删除的线性表

在这里插入图片描述

生命是有光的
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JS中的算法与数据结构之队列(Queue)实例详解
10-16
主要介绍了JS中的算法与数据结构之队列(Queue),结合实例形式详细分析了javascript中队列的概念、原理、定义及常见操作技巧,需要的朋友可以参考下
Python实现的数据结构与算法之队列详解
12-25
本文实例讲述了Python实现的数据结构与算法之队列。分享给大家供大家参考。具体分析如下： 一、概述 队列（Queue）是一种先进先出（FIFO）的线性数据结构，插入操作在队尾（rear）进行，删除操作在队首（front）进行。 二、ADT 队列ADT（抽象数据类型）一般提供以下接口： ① Queue() 创建队列 ② enqueue(item) 向队尾插入项 ③ dequeue() 返回队首的项，并从队列中删除该项 ④ empty() 判断队列是否为空 ⑤ size() 返回队列中项的个数 队列操作的示意图如下： 三、Python实现 使用Python的内建类型list列表，可以很方便地实
python数据结构：队列Queue
01-20
1.抽象数据类型Queue 1.1 1.2 2.Python实现ADT Queue 采用List来容纳Queue的数据项 将List首端作为队列尾端；List的末端作为队列首端 enqueue()复杂度为O(n) dequeue()复杂度为O(1) class Queue: #初始化 def _init_(self): self.items=[] def isEmpty(self): return self.items==[] #插入：队尾 def enqueue(self,item): self.it
第7周 项目1-建立环形队列算法库
ap_ple6223的博客
10-12 272
/* *文件名称：1.pp *作者：崔从敏 *完成日期：2015年10月12日 *问题描述：建立环形队列算法库*/ #include #include #define SQQUEUE_H_INCLUDED #define MaxSize 5 typedef char ElemType; typedef struct { ElemType data[Max
打造自己的GitHub专属主页
Augenstern_QXL的博客
02-07 3150
✍、简单记录GitHub主页美化工具
第七周项目3-负数把正数赶出队列
sunshine1119213的博客
10-12 244
/* *Copyright (c) 2017,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称：项目3-负数把正数赶出队列 *作 者：董丽娟 *完成日期：2017年10月12日 *版 本 号：v1.0 * 问题： 设从键盘输入一整数序列a1，a2，…an，试编程实现：当ai>0时，ai进队， 当ai<0时，将队首元素出队，当ai=0时，表示输入
python队列基本操作与多线程队列
侯小啾技术博客
02-03 2930
文章目录队列基本操作多线程队列 队列基本操作 from queue import Queue q = Queue(5) # 创建一个容量为5的队列。如果给一个小于0的数，则队列为无限大小。（这是官方的解释，实际不是无限大小，而是跟内存有关） # 存储数据 q.put(123) # 数值 q.put('hello world!') # 字符串 q.put(['hello', 'world']) # 列表 q.put(('hello', 'world')) # 元组 q.put({'hello'
python多线程系列—Queue对象(五)
weixin_54542209的博客
08-05 1832
8、Queue.task_done() 在完成一项工作之后，使用Queue.task_done()方法可以向队列发送一。9、Queue.join() 实际上意味着等到队列中所有的任务(数据)执行完毕之后，再往下，否则一直。7、Queue.put_nowait(item) 相当Queue.put(item, False)注意点：join()是判断的依据，不单单指的是队列中没有数据，数据get出去之后，要使。6、Queue.get_nowait() 相当Queue.get(False)...
前端LayUI框架快速上手详解(一)
热门推荐
Augenstern_QXL的博客
08-20 4万+
✍ 1、LayUI 和 Bootstrap 有些相似，但该框架有个极大的好处就是定义了很多前后端交互的样式接口，如分页表格，只需在前端配置好接口，后端则按照定义好的接口规则返回数据，即可完成页面的展示，极大减少了后端人员的开发成本。 1.1、下载与使用 官网：https://www.layui.com/ 点击立即下载即可 下载完成后解压，我们看以下其目录结构，并将其完整的拷贝到我们自己的项目下。 使用时我们只需引入下述两个文件即可使用 <!-- LayUI的核心CSS文件 --&
常见数据结构与算法C语言实现
最新发布
05-04
# 常见数据结构与算法C语言实现 内容包含常见基本数据结构实现（C语言版）如各自排序、链表、栈、队列、各种树以及应用、图算法、字符串匹配算法、回溯、并查集等 以及包含各个数据结构常见算法题的解答（C语言版...
机器学习框架Ray -- 2.1 Ray 用例整理
wenquantongxin的博客
04-06 789
为扩展机器学习而设计的Ray常见使用案例进行索引。包含对博客、示例和教程的突出引用，这些资源也可以在Ray文档的其他位置找到。Batch Inference是指在一组输入观测值上生成模型预测。该模型可以是回归模型、神经网络，也可以仅是Python函数。Ray可以将批量推断从单GPU机器扩展到大型集群。将训练模型的体系结构和权重导出到共享对象存储中，可以并行化对输入数据批量推断的过程。使用这些模型副本，Ray AIR的Batch Predictor可以跨工作进程扩展批量预测。
《黑马程序员》职工管理系统实战
ZONGXP的博客
05-29 3238
黑马程序员C++教程笔记
机器学习框架Ray -- 2.8 使用 Ray AIR训练图像分类器
wenquantongxin的博客
04-14 356
使用 Ray AI Runtime (AIR) 训练图像分类器。
那些看过一次后，就令人心里一动的美好词汇
AXYZdong的博客
05-09 993
不知道的什么词汇，但是含义却很美。
2021-06-02
weixin_44394448的博客
06-02 90
黑马程序员C++文档 C++基础入门（一）：https://blog.csdn.net/Augenstern_QXL/article/details/117249021 C++核心编程(二)： https://blog.csdn.net/Augenstern_QXL/article/details/117253848 C++提高编程(三)： https://blog.csdn.net/Augenstern_QXL/article/details/117253848 通讯录管理系统实战： https://bl
在指定文件夹中打开cmd命令窗口
Augenstern_的博客
02-07 2104
在平时的学习或者工作中，我们难免会需要用到cmd，但是：搜索cmd 或 通过运行窗口的方式打开cmd相对来说比较麻烦，我们还需要手动进入指定的磁盘与文件 故总结两个在指定文件夹中打开cmd的方法： （1） 打开指定的文件夹，按住[ shift ] 再点击 [ 鼠标右键 ]，之后在打开的菜单里选择 [ 在此处打开命令窗口 ] 【注】有的可能会显示 [ 在此处打开Powershell窗口 ]，...
循环队列的初始化、入队、出队等基本操作
weixin_34418883的博客
05-12 3704
循环队列的初始化、入队、出队等基本操作，实现代码如下：#include<iostream>using namespace std;#define TRUE 1#define FALSE 0//循环队列的类型定义#define MAXSIZE 50//队列的最大长度typedef struct{ int element[MAXSIZE];//队列的元素空间 int ...
第2章第2节练习题1 逆置队列
法海你懂不?
01-15 4399
Q是一个队列，S是一个空栈，实现将队列中的元素逆置的算法
数据结构与算法 - 队列
09-12
队列（Queue）是一种先进先出（FIFO）的数据结构，类似于现实生活中排队的概念。它有两个基本操作：入队（enqueue）和出队（dequeue）。 入队操作将元素添加到队列的末尾，出队操作则从队列的头部移除元素并返回它...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

生命是有光的

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

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

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

打赏作者

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

抵扣说明：

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

余额充值