队列

最新推荐文章于 2024-07-23 22:06:37 发布
最新推荐文章于 2024-07-23 22:06:37 发布
阅读量166 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40414160/article/details/115038682
版权

队列

队列:先进先出 FIFO—first in first out

队列的结构定义(线性结构)

结构定义

typedef struct Queue {
    int *data;
    int head, tail, length;
} Queue;

length队列的最大长度；队列的容量大小。

head队首元素的下标 tail队未元素的下标；

int *data储存连续内存首地址；

队列的操作

初始化
Queue *init(int n) {
    Queue *q =(Queue *)malloc(sizeof(Queue));
    q->data = (int *)malloc(sizeof(int) * n);
    q->length = n;
    q->head = q->tail = 0;
}

q->data = (int *)malloc(sizeof(int) * n) 开辟n*sizeof(int)大小的一连续空间，将其强转成int类型，并传给q->data.

清除

void clear(Queue *q) {
    if (q == NULL) return ;
    free(q->data);
    free(q);
    return ;
}

判空

int empty(Queue *q) {
    return q->head == q->tail;
}

通过下标判断，也可以通过其它方法。

出队

int pop(Queue *q) {
    if (q == NULL) return 0;
    if (empty(q)) return 0;
    q->head += 1;
    return 1;
}

出队时需要判空操作，向后移动 head即可。

入队

int push(Queue *q, int val) {
    if (q == NULL) return 0;
    if (q->tail == q->length) return 0;
    q->data[q->tail++] = val;
    return 1;
}

返回队首元素

int front(Queue) {
		return q->data[q->head];
}

打印

void output(Queue *q) {
    printf("Queue: [");
    for (int i = q->head; i < q->tail; i++) {
        i != q->head && printf(" ");
       printf("%d", q->data[i]);
    }
    printf("]\n");
    return ;
}

队列的假溢出

当下表 t a i l = l e n g t h tail=length tail=length 出现伪满的情况。 实际上可能出现 队列元素的个数< length​

此时，可以使用循环队列或者链表队列。

完整代码1

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
typedef struct Queue {
    int *data;
    int head, tail, length;
} Queue;

Queue *init(int n) {
    Queue *q =(Queue *)malloc(sizeof(Queue));
    q->data = (int *)malloc(sizeof(int) * n);
    q->length = n;
    q->head = q->tail = 0;
}

int empty(Queue *q) {
    return q->head == q->tail;
}

int front(Queue *q) {
    return q->data[q->head];
}

int push(Queue *q, int val) {
    if (q == NULL) return 0;
    if (q->tail == q->length) return 0;
    q->data[q->tail++] = val;
    return 1;
}

int pop(Queue *q) {
    if (q == NULL) return 0;
    if (empty(q)) return 0;
    q->head += 1;
    return 1;
}

void clear(Queue *q) {
    if (q == NULL) return ;
    free(q->data);
    free(q);
    return ;
}

void output(Queue *q) {
    printf("Queue: [");
    for (int i = q->head; i < q->tail; i++) {
        i != q->head && printf(" ");
       printf("%d", q->data[i]);
    }
    printf("]\n");
    return ;
}

int main() {
    srand(time(0));
    #define MAX_OP 20
    Queue *q = init(10);
    for (int i = 0; i < MAX_OP; i++){
        int op = rand() % 4;
        int val = rand() % 100;
        switch (op) {
            case 0:
            case 1:
            case 2: {
                printf("push %d to Queue = %d\n", val, push(q, val));
            }break;
            case 3: {
                if (empty(q)) {
                    printf("fail to pop a item!\n");
                } else {
                    printf("success to pop a item : %d\n", front(q));
                    pop(q);
                }
            }break;

        }
        output(q), printf("\n");
    }
    return 0;
}

循环队列

循环队列的结构
typedef struct Queue {
    int *data;
    int head, tail, length, count;
} Queue;

相对于常规的队列仅添加了 计数器count，用于数据的判空； 滑动数据使得tail绕到head的前面(使用取余运算%)。

初始化
Queue *init(int n) {
    Queue *q =(Queue *)malloc(sizeof(Queue));
    q->data = (int *)malloc(sizeof(int) * n);
    q->length = n;
    q->head = q->tail = 0;
    q->count = 0;
}

判空

int empty(Queue *q) {
    return q->count == 0;
}
循环队列的入队
int push(Queue *q, int val) {
    if (q == NULL) return 0;
    if (q->count == q->length) {
        if(!expand(q)) return 0;
        printf("success to expand ! the size = %d\n", q->length);
    };
    q->data[q->tail++] = val;
    if(q->tail == q->length) q->tail = 0;
    q->count += 1;
    return 1;
}

当q->tail = 1->length 是需要将 q->tail重置零，即q->tail = 0或者 q->tail %= l->length。

扩容
int expand(Queue *q) {
    int *p;
    int extr_size = q->length;
    while(extr_size){
        p = (int *)malloc(sizeof(int) *(q->length + extr_size));
        if (p != NULL) break;
        extr_size >>= 1;
    }
    if(p == NULL) return 0;
    for (int i = q->length, j = 0; j < q->count; j++) {
        p[j] = q->data[(i + j) % q->length];
    }
    free(q->data);
    q->data = p;
    q->head = 0;
    q->tail = q->count;
    q->length += extr_size;
    return 1;
}

循环扩容，连续减半扩容大小，以保证动态申请内存的成功。由于结构是循环的，head不一定是零位，如果使用realloc将会产生对后续内存的改动。

循环队列的出队
int pop(Queue *q) {
    if (q == NULL) return 0;
    if (empty(q)) return 0;
    q->head += 1;
    if(q->head == q->length) q->head = 0;
    q->count -= 1;
    return 1;
}
循化队列的打印
void output(Queue *q) {
    printf("Queue: [");
    for (int i = q->head, j = 0; j < q->count; j++) { //j偏移量
        j && printf(" ");
       printf("%d", q->data[(i + j) % q->length]);
    }
    printf("]\n");
    return ;
}

完整代码2

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
typedef struct Queue {
    int *data;
    int head, tail, length, count;
} Queue;

Queue *init(int n) {
    Queue *q =(Queue *)malloc(sizeof(Queue));
    q->data = (int *)malloc(sizeof(int) * n);
    q->length = n;
    q->head = q->tail = 0;
    q->count = 0;
}

int empty(Queue *q) {
    return q->count == 0;
}

int front(Queue *q) {
    return q->data[q->head];
}

int expand(Queue *q) {
    int *p;
    int extr_size = q->length;
    while(extr_size){
        p = (int *)malloc(sizeof(int) *(q->length + extr_size));
        if (p != NULL) break;
        extr_size >>= 1;
    }
    if(p == NULL) return 0;
    for (int i = q->length, j = 0; j<q->count; j++) {
        p[j] = q->data[(i + j) % q->length];
    }
    free(q->data);
    q->data = p;
    q->head = 0;
    q->tail = q->count;
    q->length += extr_size;
    return 1;
}


int push(Queue *q, int val) {
    if (q == NULL) return 0;
    if (q->count == q->length) {
        if(!expand(q)) return 0;
        printf("success to expand ! the size = %d\n", q->length);
    };
    q->data[q->tail++] = val;
    if(q->tail == q->length) q->tail = 0;
    q->count += 1;
    return 1;
}

int pop(Queue *q) {
    if (q == NULL) return 0;
    if (empty(q)) return 0;
    q->head += 1;
    if(q->head == q->length) q->head = 0;
    q->count -= 1;
    return 1;
}

void clear(Queue *q) {
    if (q == NULL) return ;
    free(q->data);
    free(q);
    return ;
}

void output(Queue *q) {
    printf("Queue: [");
    for (int i = q->head, j = 0; i < q->tail, j < q->count; j++) {
        j && printf(" ");
       printf("%d", q->data[(i + j) % q->length]);
    }
    printf("]\n");
    return ;
}

int main() {
    srand(time(0));
    #define MAX_OP 20
    Queue *q = init(5);
    for (int i = 0; i < MAX_OP; i++){
        int op = rand() % 4;
        int val = rand() % 100;
        switch (op) {
            case 0:
            case 1:
            case 2: {
                printf("push %d to Queue = %d\n", val, push(q, val));
            }break;
            case 3: {
                if (empty(q)) {
                    printf("fail to pop a item!\n");
                } else {
                    printf("success to pop a item : %d\n", front(q));
                    pop(q);
                }
            }break;

        }
        output(q), printf("\n");
    }
    return 0;
}

链队列

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

typedef struct Node {
    int data;
    struct Node *next;
}Node;

typedef struct Queue {
    Node head, *tail;
    int length;
}Queue;

Node *getNewNode(int);
Queue *init_LinkQueue();
int push(Queue *, int);
int pop(Queue *);
void clear_node(Node *);
void clear(Queue *);
int empty(Queue *);
int front(Queue *);

Node *getNewNode(int val) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->data = val;
    p->next = NULL;
    return p;
}

Queue *init_LinkQueue() {
    Queue *q = (Queue *)malloc(sizeof(Queue));
    q->head.next = NULL;
    q->tail = &(q->head);
    q->length = 0;
    return q;
}

int empty(Queue *q) {
    return q->length == 0;
}

int front(Queue *q) {
    return q->head.next->data;
}

int push(Queue *q, int val) {
    if (q == NULL) return 0;
    Node *node = getNewNode(val);
    q->tail->next = node;
    q->tail = node;
    q->length += 1;
    return 1;
}

int pop(Queue *q) {
    if (q == NULL) return 0;
    if (empty(q)) return 0;
    Node *temp = q->head.next;
    q->head.next = temp->next;
    clear_node(temp);
    q->length -= 1;
    if (q->length == 0) q->tail = &(q->head);
    return 1;
}

void clear_node(Node *node) {
    if(node == NULL) return ;
    free(node);
    return ;
}

void clear(Queue *q) {
    if (q == NULL) return ;
    Node *p = q->head.next, *temp;
    while (p != NULL) {
        temp = p->next;
        clear_node(p);
        p = temp;
    }
    free(q);
    return ;
}

void output(Queue *q) {
    printf("Queue(%d): [", q->length);
    for (Node *p = q->head.next; p != NULL; p = p->next) {
        p != q->head.next && printf(" ");
        printf("%d", p->data);
    }
    printf("]\n");
    return ;
}

int main() {
    srand(time(0));
    #define MAX_OP 20
    Queue *q = init_LinkQueue();
    for (int i = 0; i < MAX_OP; i++) {
        int val = rand() % 100;
        int op = rand() % 4;
        switch(op) {
            case 0:
            case 1:
            case 2: {
                printf("push %d to Queue = %d\n", val, push(q,val));
                output(q), printf("\n");
            }break;
            case 3: {
                if(empty(q)) {
                    printf("fail to pop!\n");
                }else{
                printf("success to pop %d\n", front(q));
                    pop(q);
                    output(q), printf("\n");
                }
            }break;
        }
    }
    #undef MAX_OP
    clear(q);
    return 0;
}
六月的峰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高效延时队列的设计与实现
09-02
【高效延时队列的设计与实现】 延时队列是一种特殊的消息队列，它具有延时功能，使得消息在生产者发布后不会立即被消费，而是会在预设的延时时间过后才被处理。这种机制在很多业务场景中非常有用，如订单处理、定时...
考研复习之数据结构（六）栈和队列（下）（包含队列的相关内容、栈和队列的对比以及总结）
欢迎交流！
07-03 387
目录一、队列的定义1.1 相关概念和特点（1）基本概念（2）队列特点（3）案例引入2.1 队列分类二、队列的表示和实现2.1 顺序队列的表示和实现（1）结构体定义（2）初始化操作（3）入队操作（4）出队操作（5）队列大小与判断队列是否为空2.2 链式队列的表示和实现（1）结构体定义（2）初始化操作（3）入队操作（4）出队操作（5）输出队列全部字符与判断队列是否为空2.3 双向队列的表示和实现2.4 循环队列的表示和实现（1）结构体定义（2）初始化操作（3）入队操作（4）出队操作（5）全部源码三、经典实例3.
c++ stl queue的使用
tianyexing2008的博客
08-15 1082
其内存地址是 0x400a50，成员数据随机的，再调用front()后，data指向了队列元素，其地址为：0x605060，打印出成员数据是 10，当执行完pop()后，data还是指向原地址，而CData的析构函数只是输出一行打印信息并没做其他操作。疑惑的是front() 不是返回元素的引用吗？原因为：front() 返回值赋值给的普通变量，变量 data 取到的应该是该元素的一份拷贝，如果用引用变量去接收，则不会调用拷贝构造函数，如改成：CData &data = dataQueue.front();.
队列（C语言实现）超级简洁版
weixin_45983489的博客
03-14 1362
数据结构设计 //节点数据结构 typedef struct queue_node { queue_node* next; void* data; }queue_node; //队列数据结构 typedef struct queue { queue_node* head; queue_node* tail; int length; }queue; 接口设计 //创建队列 queue* queue_create(); //入队 queue* queue_push(queue* queue,voi
探讨C++ std::queue队列涉及的拷贝问题
weixin_42479327的博客
03-23 1641
结果表明, job每次都会创建新的, 拷贝到队列时会调用拷贝构造函数, 一次for循环结束时会析构掉. 每次for循环都是如此, 认为这样的效率比较低下. 同时, job的生命周期只在for中,因此pop时的job1 变量地址会与job相同.在上述测试二中,把job的生命周期限制在一个作用域中,在作用域结束后变量job释放空间, 那么创建job1会在已释放空间上创建, 注意测试一与测试二中地址的变化.从最后打印结果也可知, job,job1两个变量是在程序结束时析构的. 测试代码二给出这点证明.
队列的顺序存储
08-07 137
typedefintPosition; structQNode{ ElementType*Data;/*存储元素的数组*/ PositionFront,Rear;/*队列的头、尾指针*/ intMaxSize;/*队列最大容量*/ }; typedefstructQNode*Qu...
C#消息队列发送及接收
03-25
在IT行业中，消息队列（Message Queue，MQ）是一种常用于分布式系统中解耦组件、提高系统可扩展性和可靠性的技术。在C#编程中，我们可以利用Microsoft Message Queuing（MSMQ）库来实现消息队列的发送和接收。本文将...
Python队列的定义与使用方法示例
09-21
Python中的队列是一种重要的数据结构，它遵循先进先出（FIFO）的原则，即最早进入队列的元素最早被移出。在实际编程中，队列常用于任务调度、多线程间的通信以及缓存管理等领域。Python标准库提供了`queue`模块，...
入门数据结构，c语言实现循环队列实现（详细篇）。
A2202333的博客
11-08 4994
队列中的一个分支循环队列，运用了一些技巧降低了其时间复杂度与空间复杂度，学会循环队列可以帮助更好的学习后面复杂的结构（如：树，二叉树，图等）。
数据结构——队列（三）
zz0377的博客
03-30 277
队列（Queue）是一个有序线性表，但队列的插入和删除操作是分别在线性表的两个不同端点进行的。 操作集 Queue CreateQueue(int MaxSize) bool IsFull(Queue Q) bool AddQ(Queue Q, ElementType X) bool IsEmpty(Queue Q) ElementType DeleteQ(Queue Q) 1.队列的顺序存储实现 typedef int Position; typedef struct QNode *PtrToQNod
数据结构（C语言描述）队列
qq_740785701的博客
03-16 503
1 队列的接本概念 队列是另一种特殊的表，这种表只在表首(队首)进行删除操作，只在表尾(为队尾)进行插入操作。由于队列的修改是按先进先出的规则进行的，所以队列又称为先进先出(First In First Out) 表， 简称FIFO表。 假设队列为a(1),a(2)……a(n)，那么a(1)就是队首元素，a(n)为队尾元素。队列中的元素是按a(1),a(2)……a(n)的顺序进入的，退出队列也只能按照这个次序依次退出。也就是说，只有在a(1)离开队列之后，a(2)才能退出队列。只有在a(1),a(2)……a
队列(Queue)
热门推荐
ChineseSoftware的博客
03-04 3万+
一、队列的概念 队列是一个先进先出的数据结构。 联想一下链表，在单链表中，只能对表尾进行插入，对表头进行结点的删除，这样强限制性的链表，就是所说的队列。也就是说，队列是限定在表的一端进行插入，表的另一端进行删除的数据结构。 如图去买票排队，每一列队伍都有一个队尾和队首，先来的先买票，后来的后买，买好的就从队首出去，新来买票的就需要从队尾继续排队。 通常，称进数据的一端为队尾，出数据的一端为队首，数据元素进队列的过程称为入队，出队列的过程称为出队。 队列是一个线性的数据结构，并且这个数据结构只允许在一端进行插
关于C++的std::queue内存不释放的问题的解决方法
zhouk的专栏
04-19 6642
最近在使用std::queue的时候，遇到一些奇怪的问题。我们使用std::queue来存放一些临时的缓冲数据，然后有一个线程不断地从queue里取数据，写入到文件中，之后会调用pop()函数将数据弹出。但是很奇怪的地在弹出的过程中，程序的内存占用丝毫没有减少。查了一些资料后发现，貌似std::queue底层自己有一套内存管理机制，只有在程序退出或是queue被销毁的时候才会释放这一部分内存。笔者...
【转】C++ queue内存释放问题
u013791761的博客
03-04 9079
      最近在使用std::queue的时候，遇到一些奇怪的问题。我们使用std::queue来存放一些临时的缓冲数据，然后有一个线程不断地从queue里取数据，写入到文件中，之后会调用pop()函数将数据弹出。但是很奇怪的地在弹出的过程中，程序的内存占用丝毫没有减少。查了一些资料后发现，貌似std::queue底层自己有一套内存管理机制，只有在程序退出或是queue被销毁的时候才会释放这一部...
PAT (Basic Level) Practice 1040 有几个PAT (25分)
a3612999a的博客
11-08 142
本题要求实现一种数字加密方法。首先固定一个加密用正整数 A，对任一正整数 B，将其每 1 位数字与 A 的对应位置上的数字进行以下运算：对奇数位，对应位的数字相加后对 13 取余——这里用 J 代表 10、Q 代表 11、K 代表 12；对偶数位，用 B 的数字减去 A 的数字，若结果为负数，则再加 10。这里令个位为第 1 位。 输入格式： 输入在一行中依次给出 A 和 B，均为不超过 100 位的正整数，其间以空格分隔。 输出格式： 在一行中输出加密后的结果。 输入样例： 1234567 3687829
算法-KMP字符串匹配
最新发布
xx_xb的博客
07-23 125
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 630
AtCoder Beginner Contest 363 ABCDE
栈和队列：进队列操作详解
"进队列enQueue(q,e)-栈和队列.PPT" 栈和队列是数据结构中的两种基础但非常重要的线性数据结构。在计算机科学中，它们被广泛应用于各种算法和程序设计中。 栈（Stack）是一种后进先出（LIFO, Last In First Out）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值