数据结构--队列

最新推荐文章于 2023-04-23 17:50:51 发布
最新推荐文章于 2023-04-23 17:50:51 发布
阅读量323 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45981481/article/details/120002698
版权
本文探讨了队列的顺序存储结构，包括使用额外空间判断队满/空，通过size变量跟踪队列长度，以及通过tag标记队满/空。此外，还介绍了链式存储队列的实现，包括带头结点和不带头结点的链式队列，并提及了双端队列的概念。代码示例展示了不同实现方式的入队、出队、获取队头元素等操作。
摘要由CSDN通过智能技术生成

目录

一 . 队列的顺序存储结构

1 . rear指向队尾指针后一个位置 牺牲一个存储空间来区分队空和队满

1-1 代码运行结果：​ 

2 . rear 指向队尾指针后一个位置 增设 size 判断队满 / 空

1-2 代码运行结果：​ 

3 . rear 指向队尾指针后一个位置 增设 tag 判断

1-3 代码运行结果：​ 

4 . rear 指向队尾 牺牲一个存储空间来区分队空和队满

1-4 代码运行结果：​ 

5 . rear 指向队尾 增设 size 判断队满 / 空

1-5 代码运行结果：​ 

6 . rear 指向队尾 增设 tag 判断

1-6 代码运行结果：​

二 . 队列的链式存储

1 . 链式队列 (带头结点)

2-1 代码运行结果：​

2 . 链式队列 (不带头结点)

2-2 代码运行结果：​

3 . 双端队列

一 . 队列的顺序存储结构

1 . rear指向队尾指针后一个位置 牺牲一个存储空间来区分队空和队满

#include <iostream>

// rear指向队尾指针后一个位置  牺牲一个存储空间来区分队空和队满

using namespace std;

#define MaxSize 10//队列元素的最大个数
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];//用静态数组存放队列元素
    int front, rear;//队头指针和队尾指针
} SqQueue;
//初始化队列
void InitQueue(SqQueue &Q) {
    //初始时 队头、队尾指针指向 0
    Q.front = Q.rear = 0;
}
//判断队列是否为空
bool QueueEmpty(SqQueue Q) {
    if(Q.front == Q.rear) { //队列为空
        return true;
    } else {
        return false;
    }
}
//判断队列是否已满
bool QueueFull(SqQueue Q) {
    if((Q.rear + 1) % MaxSize == Q.front) {
        return true;
    } else {
        return false;
    }
}
//入队
bool EnQueue(SqQueue &Q, ElemType x) {
    if(QueueFull(Q)) {
        return false;
    }
    Q.data[Q.rear] = x; // x 插入队尾
    Q.rear = (Q.rear + 1) % MaxSize; //队尾指针加 1 取模
    return true;
}
//出队
bool DeQueue(SqQueue &Q, ElemType &x) {
    if(QueueEmpty(Q)) { //队列为空
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize;
    return true;
}
//获得队头元素的值
bool GetHead(SqQueue Q, ElemType &x) {
    if(QueueEmpty(Q)) { //队列为空
        return false;
    }
    x = Q.data[Q.front];
    return true;
}
//队列元素个数
int GetQueueLength(SqQueue &Q) {
    int len = 0;
    len = (Q.rear + MaxSize - Q.front) % MaxSize;
    return len;
}
void test() {
    SqQueue Q;
    InitQueue(Q);
    for (int i = 1; i < 10; i++) {
        EnQueue(Q, i);
    }
    cout << "GetQueueLength:" << GetQueueLength(Q) << endl;
    if (!EnQueue(Q, 10)) {
        cout << "Is Full,Insertion Failed!" << endl;
    } else {
        cout << "Inserted successfully!" << endl;
    }
    cout << "GetQueueLength:" << GetQueueLength(Q) << endl;
    ElemType x;
    GetHead(Q, x);
    cout << "GetHead:" << x << endl;
    while (!QueueEmpty(Q)) {
        DeQueue(Q, x);
        cout << x << " ";
    }
    cout << endl;
}

int main() {
    test();
    return 0;
}

1-1 代码运行结果： 

2 . rear 指向队尾指针后一个位置 增设 size 判断队满 / 空

#include <iostream>

// rear 指向队尾指针后一个位置  增设 size 判断队满/空
//每次入队 size + 1
//每次出队 size - 1

using namespace std;

#define MaxSize 10//队列元素的最大个数
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];//用静态数组存放队列元素
    int front, rear;//队头指针和队尾指针
    int size;//队列当前长度
} SqQueue;
//初始化队列
void InitQueue(SqQueue &Q) {
    //初始时 队头、队尾指针指向 0
    Q.front = Q.rear = Q.size = 0;
}
//判断队列是否为空
bool QueueEmpty(SqQueue Q) {
    if(Q.size == 0) { //队列为空
        return true;
    } else {
        return false;
    }
}
//判断队列是否已满
bool QueueFull(SqQueue Q) {
    if(Q.size == MaxSize) {
        return true;
    } else {
        return false;
    }
}
//入队
bool EnQueue(SqQueue &Q, ElemType x) {
    if(QueueFull(Q)) {
        return false;
    }
    Q.data[Q.rear] = x; // x 插入队尾
    Q.rear = (Q.rear + 1) % MaxSize; //队尾指针加 1 取模
    Q.size++;
    return true;
}
//出队
bool DeQueue(SqQueue &Q, ElemType &x) {
    if(QueueEmpty(Q)) { //队列为空
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize;
    Q.size--;
    return true;
}
//获得队头元素的值
bool GetHead(SqQueue Q, ElemType &x) {
    if(QueueEmpty(Q)) { //队列为空
        return false;
    }
    x = Q.data[Q.front];
    return true;
}
//队列元素个数
int GetQueueLength(SqQueue &Q) {
    return Q.size;
}
void test() {
    SqQueue Q;
    InitQueue(Q);
    for (int i = 1; i < 10; i++) {
        EnQueue(Q, i);
    }
    cout << "GetQueueLength:" << GetQueueLength(Q) << endl;
    if (!EnQueue(Q, 10)) {
        cout << "Is Full,Insertion Failed!" << endl;
    } else {
        cout << "Inserted successfully!" << endl;
    }
    cout << "GetQueueLength:" << GetQueueLength(Q) << endl;
    ElemType x;
    GetHead(Q, x);
    cout << "GetHead:" << x << endl;
    while (!QueueEmpty(Q)) {
        DeQueue(Q, x);
        cout << x << " ";
    }
    cout << endl;
}
int main() {
    test();
    return 0;
}

1-2 代码运行结果： 

3 . rear 指向队尾指针后一个位置 增设 tag 判断

#include <iostream>

// rear 指向队尾指针后一个位置 增设 tag 判断
//每次出队操作成功时 令 tag = 0 只有出队操作 才会导致队空
//队空条件 front == rear && tag == 0
//每次入队操作成功时 令 tag = 1 只有入队操作 才会导致队满
//队满条件 front == rear && tag == 1
using namespace std;

#define MaxSize 10
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];//用静态数组存放队列元素
    int front, rear;//队头指针和队尾指针
    int tag;
} SqQueue;
//初始化
void InitQueue(SqQueue &Q) {
    Q.front = Q.rear = Q.tag = 0;
}
//判断队列是否为空
bool QueueEmpty(SqQueue Q) {
    if (Q.front == Q.rear && Q.tag == 0) {
        return true;
    }
    return false;
}
//判断队列是否已满
bool QueueFull(SqQueue Q) {
    if (Q.front == Q.rear && Q.tag == 1) {
        return true;
    }
    return false;
}
//入队
bool EnQueue(SqQueue &Q, ElemType x) {
    if (QueueFull(Q)) {//队满
        return false;
    }
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear + 1) % MaxSize;
    Q.tag = 1;
    return true;
}
//出队
bool DeQueue(SqQueue &Q, ElemType &x) {
    if (QueueEmpty(Q)) {
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize;
    Q.tag = 0;
    return true;
}
//获得队头元素的值
bool GetHead(SqQueue Q, ElemType &x) {
    if (QueueEmpty(Q)) {
        return false;
    }
    x = Q.data[Q.front];
    return true;
}
//队列元素的个数
int GetQueueLength(SqQueue Q) {
    if(QueueEmpty(Q)) {
        return 0;
    }
    if(QueueFull(Q)) {
        return MaxSize;
    }
    return (Q.rear + MaxSize - Q.front) % MaxSize;
}
void test() {
    SqQueue Q;
    InitQueue(Q);
    for (int i = 1; i < 10; i++) {
        EnQueue(Q, i);
    }
    cout << "GetQueueLength:" << GetQueueLength(Q) << endl;
    if (!EnQueue(Q, 10)) {
        cout << "Is Full,Insertion Failed!" << endl;
    } else {
        cout << "Inserted successfully!" << endl;
    }
    cout << "GetQueueLength:" << GetQueueLength(Q) << endl;
    ElemType x;
    GetHead(Q, x);
    cout << "GetHead:" << x << endl;
    while (!QueueEmpty(Q)) {
        DeQueue(Q, x);
        cout << x << " ";
    }
    cout << endl;
}
int main() {
    test();
    return 0;
}

1-3 代码运行结果： 

4 . rear 指向队尾 牺牲一个存储空间来区分队空和队满

#include <iostream>

// rear 指向队尾  牺牲一个存储空间来区分队空和队满
//队空条件 (Q.rear + 1) % MaxSize == Q.front
//队满条件 (Q.rear + 2) % MaxSize == Q.front
using namespace std;

#define MaxSize 10
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];//用静态数组存放队列元素
    int front, rear;//队头指针和队尾指针
} SqQueue;
//初始化
void InitQueue(SqQueue &Q) {
    Q.front = 0;
    Q.rear = MaxSize - 1;
}
//判断队列是否为空
bool QueueEmpty(SqQueue Q) {
    if ((Q.rear + 1) % MaxSize == Q.front) {
        return true;
    }
    return false;
}
//判断队列是否已满
bool QueueFull(SqQueue Q) {
    if ((Q.rear + 2) % MaxSize == Q.front) {
        return true;
    }
    return false;
}
//入队
bool EnQueue(SqQueue &Q, ElemType x) {
    if (QueueFull(Q)) {//队满
        return false;
    }
    Q.rear = (Q.rear + 1) % MaxSize;
    Q.data[Q.rear] = x;
    return true;
}
//出队
bool DeQueue(SqQueue &Q, ElemType &x) {
    if (QueueEmpty(Q)) {
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize;
    return true;
}
//获得队头元素的值
bool GetHead(SqQueue Q, ElemType &x) {
    if (QueueEmpty(Q)) {
        return false;
    }
    x = Q.data[Q.front];
    return true;
}
//队列元素的个数
int GetQueueLength(SqQueue Q) {
    if(QueueEmpty(Q)) {
        return 0;
    }
    if(QueueFull(Q)) {
        return MaxSize - 1;
    }
    return (Q.rear + MaxSize + 1 - Q.front) % MaxSize;
}
void test() {
    SqQueue Q;
    InitQueue(Q);
    for (int i = 1; i < 4; i++) {
        EnQueue(Q, i);
    }
    cout << "GetQueueLength:" << GetQueueLength(Q) << endl;
    if (!EnQueue(Q, 10)) {
        cout << "Is Full,Insertion Failed!" << endl;
    } else {
        cout << "Inserted successfully!" << endl;
    }
    cout << "GetQueueLength:" << GetQueueLength(Q) << endl;
    ElemType x;
    GetHead(Q, x);
    cout << "GetHead:" << x << endl;
    while (!QueueEmpty(Q)) {
        DeQueue(Q, x);
        cout << x << " ";
    }
    cout << endl;
}
int main() {
    test();
    return 0;
}

1-4 代码运行结果： 

5 . rear 指向队尾 增设 size 判断队满 / 空

#include <iostream>

// rear 指向队尾  增设 size 判断队满/空
//每次入队 size + 1
//每次出队 size - 1
using namespace std;

#define MaxSize 10
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];//用静态数组存放队列元素
    int front, rear;//队头指针和队尾指针
    int size;
} SqQueue;
//初始化
void InitQueue(SqQueue &Q) {
    Q.front = 0;
    Q.rear = MaxSize - 1;
    Q.size = 0;
}
//判断队列是否为空
bool QueueEmpty(SqQueue Q) {
    if (Q.size == 0) {
        return true;
    }
    return false;
}
//判断队列是否已满
bool QueueFull(SqQueue Q) {
    if (Q.size == MaxSize) {
        return true;
    }
    return false;
}
//入队
bool EnQueue(SqQueue &Q, ElemType x) {
    if (QueueFull(Q)) {//队满
        return false;
    }
    Q.rear = (Q.rear + 1) % MaxSize;
    Q.data[Q.rear] = x;
    Q.size++;
    return true;
}
//出队
bool DeQueue(SqQueue &Q, ElemType &x) {
    if (QueueEmpty(Q)) {
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize;
    Q.size--;
    return true;
}
//获得队头元素的值
bool GetHead(SqQueue Q, ElemType &x) {
    if (QueueEmpty(Q)) {
        return false;
    }
    x = Q.data[Q.front];
    return true;
}
//队列元素的个数
int GetQueueLength(SqQueue Q) {
    return Q.size;
}
void test() {
    SqQueue Q;
    InitQueue(Q);
    for (int i = 1; i < 10; i++) {
        EnQueue(Q, i);
    }
    cout << "GetQueueLength:" << GetQueueLength(Q) << endl;
    if (!EnQueue(Q, 10)) {
        cout << "Is Full,Insertion Failed!" << endl;
    } else {
        cout << "Inserted successfully!" << endl;
    }
    cout << "GetQueueLength:" << GetQueueLength(Q) << endl;
    ElemType x;
    GetHead(Q, x);
    cout << "GetHead:" << x << endl;
    while (!QueueEmpty(Q)) {
        DeQueue(Q, x);
        cout << x << " ";
    }
    cout << endl;
}
int main() {
    test();
    return 0;
}

1-5 代码运行结果： 

6 . rear 指向队尾 增设 tag 判断

#include <iostream>

// rear 指向队尾  增设 tag 判断
//每次出队操作成功时 令 tag = 0 只有出队操作 才会导致队空
//队空条件 Q.front == (Q.rear + 1) % MaxSize && Q.tag == 0
//每次入队操作成功时 令 tag = 1 只有入队操作 才会导致队满
//队满条件 Q.front == (Q.rear + 1) % MaxSize && Q.tag == 1
using namespace std;

#define MaxSize 10
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];//用静态数组存放队列元素
    int front, rear;//队头指针和队尾指针
    int tag;
} SqQueue;
//初始化
void InitQueue(SqQueue &Q) {
    Q.front = 0;
    Q.rear = MaxSize - 1;
    Q.tag = 0;
}
//判断队列是否为空
bool QueueEmpty(SqQueue Q) {
    if (Q.front == (Q.rear + 1) % MaxSize && Q.tag == 0) {
        return true;
    }
    return false;
}
//判断队列是否已满
bool QueueFull(SqQueue Q) {
    if (Q.front == (Q.rear + 1) % MaxSize && Q.tag == 1) {
        return true;
    }
    return false;
}
//入队
bool EnQueue(SqQueue &Q, ElemType x) {
    if (QueueFull(Q)) {//队满
        return false;
    }
    Q.rear = (Q.rear + 1) % MaxSize;
    Q.data[Q.rear] = x;
    Q.tag = 1;
    return true;
}
//出队
bool DeQueue(SqQueue &Q, ElemType &x) {
    if (QueueEmpty(Q)) {
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize;
    Q.tag = 0;
    return true;
}
//获得队头元素的值
bool GetHead(SqQueue Q, ElemType &x) {
    if (QueueEmpty(Q)) {
        return false;
    }
    x = Q.data[Q.front];
    return true;
}
//队列元素的个数
int GetQueueLength(SqQueue Q) {
    if(QueueEmpty(Q)) {
        return 0;
    }
    if(QueueFull(Q)) {
        return MaxSize;
    }
    return (Q.rear + MaxSize + 1 - Q.front) % MaxSize;
}
void test() {
    SqQueue Q;
    InitQueue(Q);
    for (int i = 1; i < 10; i++) {
        EnQueue(Q, i);
    }
    cout << "GetQueueLength:" << GetQueueLength(Q) << endl;
    if (!EnQueue(Q, 10)) {
        cout << "Is Full,Insertion Failed!" << endl;
    } else {
        cout << "Inserted successfully!" << endl;
    }
    cout << "GetQueueLength:" << GetQueueLength(Q) << endl;
    ElemType x;
    GetHead(Q, x);
    cout << "GetHead:" << x << endl;
    while (!QueueEmpty(Q)) {
        DeQueue(Q, x);
        cout << x << " ";
    }
    cout << endl;
}
int main() {
    test();
    return 0;
}

1-6 代码运行结果：

二 . 队列的链式存储

1 . 链式队列 (带头结点)

#include <iostream>

//链式队列 (带头结点)
using namespace std;

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

typedef struct { //链式队列
    LinkNode *front, *rear; //链式队列的队头和队尾指针
} LinkQueue;
//初始化
void InitQueue(LinkQueue &Q) {
    Q.front = Q.rear = (LinkNode *)malloc(sizeof(LinkNode));//建立头结点
    Q.front->next = NULL;//初始为空
}
//判断队列为空
bool QueueEmpty(LinkQueue Q) {
    if(Q.front == Q.rear) {
        return true;
    } else {
        return false;
    }
}
//入队
bool EnQueue(LinkQueue &Q, ElemType x) {
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    if(!s) { //空间申请失败
        return false;
    }
    //创建新结点插入队尾
    s->data = x;
    s->next = NULL;
    Q.rear->next = s;
    Q.rear = s;
}
//出队
bool DeQueue(LinkQueue &Q, ElemType &x) {
    if(QueueEmpty(Q)) { //空队
        return false;
    }
    LinkNode *p = Q.front->next;
    x = p->data;
    Q.front->next = p->next;
    if(Q.rear == p) { //队列最后一个元素
        Q.front = Q.rear;
    }
    free(p);
    return true;
}
//获得队头元素
bool GetHead(LinkQueue Q, ElemType &x) {
    if(QueueEmpty(Q)) { //空队
        return false;
    }
    x = Q.front->next->data;
    return true;
}
void test() {
    LinkQueue Q;
    InitQueue(Q);
    for (int i = 0; i < 10; i++) {
        EnQueue(Q, i);
    }
    ElemType x;
    GetHead(Q, x);
    cout << "GetHead:" << x << endl;
    while(!QueueEmpty(Q)) {
        DeQueue(Q, x);
        cout << x << " ";
    }
    cout << endl;
}
int main() {
    test();
    return 0;
}

2-1 代码运行结果：

2 . 链式队列 (不带头结点)

#include <iostream>

//链式队列 (不带头结点)
using namespace std;

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

typedef struct { //链式队列
    LinkNode *front, *rear; //链式队列的队头和队尾指针
} LinkQueue;
//初始化
void InitQueue(LinkQueue &Q) {
    Q.front = Q.rear = NULL; //初始为空
}
//判断队列为空
bool QueueEmpty(LinkQueue Q) {
    if(Q.front == NULL) {
        return true;
    } else {
        return false;
    }
}
//入队
bool EnQueue(LinkQueue &Q, ElemType x) {
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    if(!s) { //空间申请失败
        return false;
    }
    //创建新结点插入队尾
    s->data = x;
    s->next = NULL;
    if(QueueEmpty(Q)) {
        Q.front = Q.rear = s;
    } else {
        Q.rear->next = s;
        Q.rear = s;
    }
    return true;
}
//出队
bool DeQueue(LinkQueue &Q, ElemType &x) {
    if(QueueEmpty(Q)) { //空队
        return false;
    }
    LinkNode *p = Q.front;
    x = p->data;
    if(Q.rear == p) { //队列最后一个元素
        Q.front = Q.rear = NULL;
    } else {
        Q.front = p->next;
    }
    free(p);
    return true;
}
//获得队头元素
bool GetHead(LinkQueue Q, ElemType &x) {
    if(QueueEmpty(Q)) { //空队
        return false;
    }
    x = Q.front->data;
    return true;
}
void test() {
    LinkQueue Q;
    InitQueue(Q);
    for (int i = 0; i < 10; i++) {
        EnQueue(Q, i);
    }
    ElemType x;
    GetHead(Q, x);
    cout << "GetHead:" << x << endl;
    while(!QueueEmpty(Q)) {
        DeQueue(Q, x);
        cout << x << " ";
    }
    cout << endl;
}
int main() {
    test();
    return 0;
}

2-2 代码运行结果：

3 . 双端队列

//双端队列

//1. 输入受限的双端队列 可以两端删除 但只可一端输入
//2. 输出受限的双端队列 可以两端输入 但只可一端删除

//双端队列具有栈的所有功能

//!!!考点
//判断输出序列的合法性
我这么好看
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构-队列实验报告.docx
11-29
数据结构-队列实验报告 本实验报告的主要目标是设计和实现一个队列数据结构，包括链队列、顺序队列和循环队列三个部分。通过对每种队列的设计和实现，学生可以更好地理解队列的基本操作和实现原理。 一、需求分析 ...
数据结构-循环队列-C语言实现循环队列-数据结构学习
最新发布
05-27
C语言实现的数据结构中的循环队列 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件，以及测试用的main.c文件 用于C语言以及数据结构的学习 循环队列的.c和.h文件实现了以下功能： 创建循环队列 入队列...
【数据结构】队列的实现及应用和循环队列的实现【完整版】
m0_74044018的博客
04-23 1903
讲解队列的概念和实现，队列的应用、队列的几道经典编程题，队列的概念选择题【完整版】
C语言-队列（链式队列，循环队列）
m0_63223213的博客
07-06 2039
循环队列和链式队列详解及相关测试
【纯C语言】数据结构：循环队列
fangzelin5的博客
03-26 744
【纯C语言】数据结构之循环队列的构建
第七周项目3-负数把正数赶出队列
sunshine1119213的博客
10-12 255
/* *Copyright (c) 2017,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称：项目3-负数把正数赶出队列 *作 者：董丽娟 *完成日期：2017年10月12日 *版 本 号：v1.0 * 问题： 设从键盘输入一整数序列a1，a2，…an，试编程实现：当ai>0时，ai进队， 当ai<0时，将队首元素出队，当ai=0时，表示输入
c语言 initqueue头文件,void main(){ Queue Q;InitQueue(Q); char x='e';y='c'; EnQueue(Q,'r');EnQueue(Q,y); D...
weixin_36012215的博客
05-25 2900
满意答案brnxa1372015.10.11采纳率：51%等级：10已帮助：768人题目没有打全。如果是：void main( ){Queue Q; Init Queue (Q);Char x=’e’; y=’c’;EnQueue (Q,’h’); EnQueue (Q,’r’); EnQueue (Q, y);DeQueue (Q,x); EnQueue (Q,x);DeQueue (Q...
数据结构--队列--思维导图.pdf
08-29
数据结构--队列--思维导图.pdf 数据结构中，队列（Queue）是一种重要的抽象数据类型，具有重要的应用价值。队列是一种特殊的线性表，它只允许在一端进行插入，另一端进行删除。队列的基本概念和操作将在下面详细...
数据结构--队列实验报告.docx
03-24
数据结构中的队列是一种线性数据结构，它遵循“先进先出”（FIFO, First In First Out）的原则。在本实验报告中，主要探讨了三种类型的队列：链队列、顺序队列和循环队列。 1. 链队列： 链队列是由一系列节点组成...
数据结构--队列.ppt
07-11
【队列】是一种重要的数据结构，它遵循先进先出（First In First Out，简称FIFO）的原则。在队列中，元素的添加（入队）发生在队尾，而元素的删除（出队）则发生在队首。队列的应用广泛，如图形的广度优先搜索、...
C++数据结构 -- 队列
11-30
在编程领域，数据结构是构建高效算法的基础，而队列是一种基本且重要的数据结构。队列遵循“先进先出”（FIFO，First In First Out）原则，这意味着最先被添加到队列中的元素也将最先被处理。在C++中实现队列，我们...
数据结构-栈和队列-PPT
02-04
"数据结构-栈和队列-PPT" 数据结构中栈和队列是两种常用的线性表结构，下面对它们的定义、特点和应用进行详细介绍。 栈的定义和特点 栈是一种只能在一端（栈顶）进行插入和删除运算的线性表。栈的逻辑结构与...
数据结构-顺序队列
09-12
顺序队列是数据结构中的一种基本类型，它的实现方式简单直观，适用于许多基础的算法和问题。在这个项目中，我们将深入探讨顺序队列的概念、实现以及在C语言中的应用。 顺序队列是一种线性数据结构，其元素在内存中...
嵌入式常用数据结构------队列操作简介
08-21
队列是一种特殊的数据结构，它遵循“先进先出”（First In First Out，简称FIFO）的原则，类似于现实生活中的排队购票场景。在嵌入式软件开发中，队列被广泛应用于处理顺序执行的任务，例如任务调度、数据传输、消息...
数据结构-栈与队列
01-07
数据结构-栈与队列一、顺序栈1.顺序栈的定义2：入栈二、顺序队列1：顺序栈的定义2：入队3：出队三、链队列1：链队列的定义：2：入队3：出队 一、顺序栈 1.顺序栈的定义 #define MaxSize 64 /* const int MaxSize =64...
队列
gz_gy的专栏
03-23 614
//以下是Queue.hstruct Queue{    ElemType queue[QueueMaxSize];    int front,rear;};void InitQueue(Queue& Q){    Q.front=Q.rear=0;}void ClearQueue(Queue& Q){    Q.front=Q.rear=0;//对于顺序队列，此算法与初始化队列的算法相同}i
数据结构 之 图的存储和遍历
weixin_30263277的博客
03-26 112
////2012.03.26 by zhengshihao#include<stdio.h>#define GRAPHMAX 10#define FALSE 0#define TRUE 1#define Error printf#define QueueSize 30typedef struct{ char vexs[GRAPHMAX]; int edges[GRAP...
队列(Queue) ——(一)静态线式实现
chenchen_fcj程序猿的博客
07-28 427
队列 特点：先进先出 这里主要讲下静态线式的实现，由于普通队列会导致空间浪费，所以主要讲循环队列。 其中：由于特点是先进先出，所以需要两个可以动的指针分别来表示进（rear）和出（front）。 当front == rear时，表示空。 表示满的方法则比较特别，因为两个动态指针就很难表示满了，所以这里少用了一个存储空间，也就是数组的最后一个存数空间不用，当 (rear+1)%maxsiz...
数据结构_顺序队列
qq_44864056的博客
05-08 538
1 队列 1.1 队列的定义 1） 队列简称队，它是一种操作受限的线性表，其限制为在标的一段进行插入，而在包的另一端进行删除。把进行插入的一端称为队尾(rear)，把进行删除的一端称作队头或队首(front)。向队列中插入新元素称为进队或入队，新的元素进队后就成为新的队尾元素；从队列中删除元素称为出队或离队，元素出队后，其直接后继元素就成为队首元素。 2）由于队列的插入和删除操作分别在各自的一端进...
数据结构-队列的应用
07-28
回答: 队列是一种常见的数据结构，它遵循先进先出（FIFO）的原则。队列的应用非常广泛。其中一种应用是在操作系统中进行进程调度。操作系统使用队列来管理进程的执行顺序，确保每个进程按照一定的规则得到执行的机会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我这么好看

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

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

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

打赏作者

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

抵扣说明：

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

余额充值