【从零开始的嵌入式生活】数据结构4——栈与队列(2)

简介: 【从零开始的嵌入式生活】数据结构4——栈与队列(2)

链式队列

插入操作在队尾进行,删除操作在队头进行,由队头指针和队尾指针控制队列的操作。

结构体定义:


相关操作

linkqueue * queue_create(){
        linkqueue *lq;
        if((lq = (linkqueue *)malloc(sizeof(linkqueue))) == NULL){
                printf("malloc linkqueue failed\n");
                return NULL;
        }
        lq->front = lq->rear = (linklist)malloc(sizeof(listnode));
        if(lq->front == NULL){
                printf("malloc node failed\n");
                free(lq);
                return NULL;
        }
        lq->front->data = 0;
        lq->front->next = NULL;
        return lq;
}
int enqueue(linkqueue *lq, datatype x){
        linklist p;
        if(lq == NULL){
                printf("lq is null\n");
                return -1;
        }
        if((p = (linklist)malloc(sizeof(listnode))) == NULL){
                printf("malloc node failed\n");
                return -1;
        }
        p->data = x;
        p->next = NULL;
        lq->rear->next = p;
        lq->rear = p;
        return 0;
}
datatype dequeue(linkqueue *lq){
        linklist p;
        if(lq == NULL){
                printf("lq is null\n");
                return -1;
        }
        p = lq->front;
        lq->front = p->next;
        free(p);
        return lq->front->data;
}
int queue_empty(linkqueue *lq){
        if(lq == NULL){
                printf("lq is null\n");
                return -1;
        }
        return (lq->front == lq->rear ? 1: 0);
}
int queue_clear(linkqueue *lq){
        linklist p;
        if(lq == NULL){
                printf("lq is null\n");
                return -1;
        }
        if(!lq->front){
                return 0;
        }
        while(lq->front->next){
                p = lq->front;
                lq->front = p->next;
                printf("free:%d\n",p->data);
                free(p);
        }
        return 0;
}
linkqueue * queue_free(linkqueue *lq){
        linklist p;
        if(lq == NULL){
                printf("lq is null\n");
                return lq;
        }
        while(lq->front){
                p = lq->front;
                lq->front = p->next;
                printf("free :%d\n" ,p->data);
                free(p);
        }
        free(lq);
        return NULL;
}

栈和队列的应用

球钟是一个利用球的移动来记录时间的的简单装置。

它有三个可以容纳若干球的指示器:分钟指示器,五分钟指示器,小时指示器

如:分钟指示器有2个球,五分钟指示器6个球,小时指示器有5个球,则时间为5:32


工作原理:

每过一分钟,球钟就会从一个队列的队首取出一个球放入分钟指示器,分钟指示器最多可以容纳4个球。

当放入第5个球时,在分钟指示器的4个球就会按照他们被放入时的顺序加入球队列的队尾。而第五个球就会进入五分钟指示器。

按此类推,五分钟指示器最多可放11个球,小时指示器最多可以放11个球。


问题:

现设初始时队列的球数为27,球钟的三个指示器初始状态均为空。问:要经过多久,球队列才能回复到原来的顺序?


解决代码

#include <stdio.h>
#include "linkqueue.h"
#include "sqstack.h"
int check(linkqueue *lq);
int main(int argc, const char *argv[]){
        linkqueue *lq;
        sqstack *s_hour, *s_five, *s_min;
        int i, min = 0;
        int value;
        if((lq = queue_create()) == NULL){
                return -1;
        }
        for(i = 1; i <= 27; ++i){
                enqueue(lq,i);
        }
        if((s_hour = stack_create(11)) == NULL) return -1;
        if((s_five = stack_create(11)) == NULL) return -1;
        if((s_min = stack_create(4)) == NULL)   return -1;
        while(1){
                min++;
                if(!queue_empty(lq)){
                        value = dequeue(lq);
                        if(!stack_full(s_min)){
                                stack_push(s_min, value);
                        }else{
                                while(!stack_empty(s_min)){
                                        enqueue(lq, stack_pop(s_min));
                                }
                                if(!stack_full(s_five)){
                                        stack_push(s_five,value);
                                }else{
                                        while(!stack_empty(s_five)){
                                                enqueue(lq, stack_pop(s_five));
                                        }
                                        if(!stack_full(s_hour)){
                                                stack_push(s_hour,value);
                                        }else{
                                                while(!stack_empty(s_hour)){
                                                        enqueue(lq, stack_pop(s_hour));
                                                }
                                                enqueue(lq, value);
                                                if(check(lq) == 1)
                                                        break;
                                        }
                                }
                        }
                }
        }
        printf("total:%d\n",min);
        return 0;
}
int check(linkqueue *lq){
        linklist p;
        if(lq == NULL){
                printf("lq is null\n");
                return -1;
        }
        p = lq->front->next;
        while(p && p->next){
                if(p->data < p->next->data)
                        p = p->next;
                else return 0;
        }
        return 1;
}


写在最后

栈和队列内容有点多,我失策了,导致昨天没正常更新,今天很多内容需要去gitee仓库里找我练习的代码跟着写来理解,大家加油,接下来的几天时间会继续了解各种数据结构,我尽量一天一更,大家和我一起变强呀!最后三连即可提高学习效率!!!


另外我在更新的就是算法笔记的一些例题笔记,这个系列是用于提高我的算法能力,如果有兴趣对算法领域感兴趣找不到合适的入门文章也可以追更,如果我更新的太慢了请大家点赞收藏,一键三连才能更有更新的动力呀0.0


相关文章
|
2天前
|
存储 NoSQL C语言
数据结构——顺序栈与链式栈的实现-2
数据结构——顺序栈与链式栈的实现
数据结构——顺序栈与链式栈的实现-2
|
2天前
|
存储 C语言
数据结构——顺序栈与链式栈的实现-1
数据结构——顺序栈与链式栈的实现
数据结构——顺序栈与链式栈的实现-1
|
2天前
栈的基本应用
栈的基本应用
12 3
|
2天前
栈与队列理解
栈与队列理解
13 1
|
2天前
|
存储 算法
数据结构与算法 栈与队列
数据结构与算法 栈与队列
12 0
数据结构与算法 栈与队列
|
2天前
|
C++
数据结构(顺序队列 循环队列
数据结构(顺序队列 循环队列
10 0
|
2天前
|
C++
数据结构(共享栈
数据结构(共享栈
8 0
|
2天前
|
C++
数据结构(顺序栈
数据结构(顺序栈
13 2
|
2天前
|
容器
【栈与队列】栈与队列的相互转换OJ题
栈:一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶,另一端称为栈底。栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。
10 0
|
2天前
|
机器学习/深度学习 算法 测试技术
【单调栈】3113. 边界元素是最大值的子数组数目
【单调栈】3113. 边界元素是最大值的子数组数目