队列、栈（数据结构）

最新推荐文章于 2024-12-08 15:04:15 发布
原创 最新推荐文章于 2024-12-08 15:04:15 发布 · 355 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#栈 #队列

介绍

  • 队列是一种先进先出（First In First Out）的线性表，只允许在线性表的一端进行插入操作，在另一端进行删除操作。允许插入的一端称为队尾，允许删除的一端称为队头。可以将队列想象成一个管道，数据从一边进入，从另一边流出。所以有时候队列也称为管道（pipe）。
  • 栈是一种只能后进先出（Last In First Out）的数据结构，表现为只能在线性表的尾部进行插入和删除操作。其中，把数据插入栈称为压栈（Push），把数据从栈中取出来称为弹栈（Pop）。

队列

/*************************************************************************
    > File Name: arrQueue.c
    > Author: mrhjlong
    > Mail: mrhjlong@163.com 
    > Created Time: 2016年04月24日 星期日 14时58分21秒
 ************************************************************************/

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

#define MAXSIZE        100
#define QUEUE_FULL     1
#define QUEUE_NOT_FULL 0
#define ERROR          -1
#define OK             2

typedef int type_t;

typedef struct
{
    type_t data[MAXSIZE];
    int writePtr;
    int readPtr;
    int flag;
}Queue;

//创建队列
Queue *queue_create()
{
    Queue *q = (Queue *)malloc(sizeof(Queue));
    q->writePtr = 0;
    q->readPtr = 0;
    q->flag = QUEUE_NOT_FULL;
    return q;
}

//销毁队列
void queue_destroy(Queue *q)
{
    if(q != NULL)
        free(q);
}

//入队
int enQueue(Queue *q, type_t data)
{
    if(q->flag == QUEUE_FULL)
        return ERROR;
    else
    {
        q->data[q->writePtr] = data;
        q->writePtr = (q->writePtr + 1) % MAXSIZE;

        if(q->writePtr == q->readPtr)
            q->flag = QUEUE_FULL;

        return OK;
    }
}

//出队
int deQueue(Queue *q, type_t *pData)
{
    if(q->writePtr == q->readPtr && q->flag == QUEUE_NOT_FULL)
        return ERROR;
    else
    {
        *pData = q->data[q->readPtr];
        q->readPtr = (q->readPtr + 1) % MAXSIZE;

        if(q->flag == QUEUE_FULL)
            q->flag = QUEUE_NOT_FULL;

        return OK;
    }
}

//获取队列长度
int queueLength(Queue *q)
{
    if(q->writePtr > q->readPtr)
        return q->writePtr - q->readPtr;
    else if(q->writePtr < q->readPtr)
        return MAXSIZE + q->readPtr - q->writePtr;
    else 
    {
        if(q->flag == QUEUE_FULL)
            return MAXSIZE;
        else
            return 0;
    }
}


int main()
{
    int i = 0;
    int temp = 0;

    Queue *q = queue_create();

    for(i = 0; i < 10; i++)
        enQueue(q, i);

    printf("length : %d\n", queueLength(q));

    for(i = 0; i < 10; i++)
    {
        deQueue(q, &temp);
        printf("dequeue : %d\n", temp);
    }

    printf("length : %d\n", queueLength(q));

    queue_destroy(q);

    return 0;
}

栈（顺序存储1）

/*************************************************************************
    > File Name: arrStack.c
    > Author: mrhjlong
    > Mail: mrhjlong@163.com 
    > Created Time: 2016年04月24日 星期日 10时06分33秒
 ************************************************************************/

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

#define MAXSIZE 100
#define ERROR   -1
#define OK      0

typedef int type_t;

typedef struct
{
    type_t data[MAXSIZE];
    int index;
}Stack;

//创建
Stack *stack_create()
{
    Stack *s = (Stack *)malloc(sizeof(Stack));
    s->index = 0;
    return s;
}

//销毁
void stack_destroy(Stack *s)
{
    if(s != NULL)
        free(s);
    return;
}

//压栈
int push(Stack *s, type_t data)
{
    if(s->index == MAXSIZE)
        return ERROR;
    else
    {
        s->data[s->index] = data;
        s->index++;
        return OK;
    }
}

int pop(Stack *s, type_t *pData)
{
    if(s->index == 0)
    {
        return ERROR;
    }
    else
    {
        s->index--;
        *pData = s->data[s->index];
        return OK;
    }
}

void stack_print(Stack *s)
{
    type_t i;
    for(i = 0; i < s->index; i++)
        printf("%d ", s->data[i]);
    printf("\n");
}

//获取栈的顶端元素
int get_head(Stack *s)
{
    if(s != NULL)
        return s->data[s->index - 1];
}

//栈顶减一
void pop_null(Stack *s)
{
    if(s != NULL)
        s->index--;
}

//打印栈的大小
int stack_size(Stack *s)
{
    if(s != NULL)
        return s->index;
}

int main()
{
    Stack *s = stack_create();
    type_t a[10] = {0};
    type_t i;
    char str[] = "931-3*+62/+";

    for(i = 0; i < 11; i++)
    {
        if(push(s, i) == OK)
            stack_print(s);
        else
            printf("ERROR!\n");
    }
    pop(s, a);
    pop(s, a + 1);
    pop(s, a + 2);

    for(i = 0; i < 3; i++)
        printf("%d ", a[i]);
    printf("\n");
    stack_print(s);

    return 0;
}

栈（顺序存储2）

/*************************************************************************
    > File Name: arrStack.c
    > Author: mrhjlong
    > Mail: mrhjlong@163.com 
    > Created Time: 2016年04月24日 星期日 10时06分33秒
 ************************************************************************/

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

#define ERROR -1
#define OK    0

typedef int type_t;

typedef struct
{
    type_t *data;
    int index;
    int size;
}Stack;

//创建
Stack *stack_create(int size)
{
    Stack *s = (Stack *)malloc(sizeof(Stack));
    s->data = (type_t *)malloc(size * sizeof(type_t));
    s->index = 0;
    s->size = size;
    return s;
}

//销毁
void stack_destroy(Stack *s)
{
    if(s != NULL)
    {
        free(s->data);
        free(s);
    }
    return;
}

//压栈
int push(Stack *s, type_t data)
{
    if(s->index == s->size)
        return ERROR;
    else
    {
        s->data[s->index] = data;
        s->index++;
        return OK;
    }
}

int pop(Stack *s, type_t *pData)
{
    if(s->index == 0)
    {
        return ERROR;
    }
    else
    {
        s->index--;
        *pData = s->data[s->index];
        return OK;
    }
}

void stack_print(Stack *s)
{
    type_t i;
    for(i = 0; i < s->index; i++)
        printf("%d ", s->data[i]);
    printf("\n");
}

//获取栈的顶端元素
int get_Head(Stack *s)
{
    if(s != NULL)
        return s->data[s->index - 1];
}

//栈顶减一
void pop_null(Stack *s)
{
    if(s != NULL)
        s->index--;
}

//打印栈的大小
int stack_size(Stack *s)
{
    if(s != NULL)
        return s->index;
}

const char *str = "((unsigned long)&(((type_t*)0)->member))";

int check(const char *str)
{
    Stack *s = stack_create(10);
    int len = strlen(str);
    int i;
    for(i = 0; i < len; i++)
    {
        if(s->index < 0)
        {
            stack_destroy(s);
            return ERROR;
        }
        if(str[i] == '(')
        {
            push(s, 1);
        }
        if(str[i] == ')')
        {
            pop_null(s);
        }
    }
    stack_destroy(s);

    if(s->index == 0)
        return OK;
    else
        return ERROR;
}

int main()
{
    Stack *s = stack_create(10);
    type_t a[10] = {0};
    type_t i;

    for(i = 0; i < 11; i++)
    {
        if(push(s, i) == OK)
            stack_print(s);
        else
            printf("ERROR!\n");
    }
    pop(s, a);
    pop(s, a + 1);
    pop(s, a + 2);

    for(i = 0; i < 3; i++)
        printf("%d ", a[i]);
    printf("\n");

    stack_print(s);
    printf("\n");

    if(check(str) == OK)
        printf("OK!\n");
    else
        printf("ERROR!\n");

    return 0;
}

栈（链式存储）

/*************************************************************************
    > File Name: listStack.c
    > Author: mrhjlong
    > Mail: mrhjlong@163.com 
    > Created Time: 2016年04月24日 星期日 10时06分33秒
 ************************************************************************/

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

#define MAXSIZE 10
#define ERROR -1
#define OK 0

typedef int type_t;

typedef struct node
{
    type_t data;
    struct node *next;
}QNode;


typedef struct
{
    QNode *head;
    int index;
}Stack;

//创建
Stack *stack_create()
{
    Stack *s = (Stack *)malloc(sizeof(Stack));
    s->head = NULL;
    s->index = 0;
    return s;
}

//销毁
void stack_destroy(Stack *s)
{
    if(s != NULL)
        free(s);
    return;
}

//压栈
int push(Stack *s, type_t data)
{
    //链表头插法
    QNode *pNode = (QNode *)malloc(sizeof(QNode));

}

int pop(Stack *s, type_t *pData)
{
    //删除节点
    if(s->index == 0)
    {
        return ERROR;
    }
    else
    {
        s->index--;
        *pData = s->data[s->index];
        return OK;
    }
}

void stack_print(Stack *s)
{
    type_t i;
    for(i = 0; i < s->index; i++)
        printf("%d ", s->data[i]);
    printf("\n");
}

//获取栈的顶端元素
int get_Head(Stack *s)
{
    if(s != NULL)
        return s->data[s->index - 1];
}

//栈顶减一
void pop_null(Stack *s)
{
    if(s != NULL)
        s->index--;
}

//打印栈的大小
int stack_size(Stack *s)
{
    if(s != NULL)
        return s->index;
}

int main()
{
    Stack *s = stack_create();
    type_t a[10] = {0};
    type_t i;

    for(i = 0; i < 11; i++)
    {
        if(push(s, i) == OK)
            stack_print(s);
        else
            printf("ERROR!\n");
    }
    pop(s, a);
    pop(s, a + 1);
    pop(s, a + 2);

    for(i = 0; i < 3; i++)
        printf("%d ", a[i]);
    printf("\n");
    stack_print(s);

    return 0;
}
数据结构 栈和队列
qq_52847866的博客
06-15 4910
5. 访问效率：顺序存储结构的元素在内存中是连续存储的，对于 CPU 缓存等硬件有较好的利用效率，因此在访问速度上可能更快。特殊矩阵的压缩存储可以大幅减少存储空间的占用，提高存储效率，并在某些情况下加速矩阵的运算和操作。需要注意的是，多维数组的存储方式可能会影响程序的性能，特别是对于大型多维数组和对数组访问频繁的场景。总之，栈和队列都是重要的数据结构，在不同的应用场景中发挥着关键的作用。栈和队列都是常见的数据结构，可以使用不同的存储结构进行实现，包括顺序存储结构和链式存储结构。函数判断栈是否为空。
深度学习--基于队列的数据随机载入
qq_34992900的博客
09-01 312
起因： 最近在处理数据，训练深度学习模型的时候，发现使用pytorch中的dataloader的时候会占用大量缓存，拖慢数据的处理速度，凑巧在学习 李沐老师的深度学习课程时，李沐老师给出了解决方案， 解决方案如下： 将数据保存硬盘上，每次读取两个batch，一个batch直接用于训练，一个batch备用，这样可以尽可能少的占用缓存，同时保证运行速度 以下是我的解决方案，主要思想是基于队列先进先出的思想，首先使用python构建队列： class Queue: def __in..
C 语言通用模板队列（宏函数）
大橙子的博客
06-28 988
使用宏定义函数实现 C 语言队列的功能
nginx 源码学习(四) 基本数据结构 ngx_queue_t
Daniel 的技术笔记 不积跬步无以至千里，不积小流无以成江海。
02-09 5738
nginx 队列结构 ngx_queue_t  介绍 由于nginx 具有跨平台及C语言实现的特点，使nginx不宜使用一些第三方中间件提供的容器和算法，跨平台(linux,windows等)的特点， 因此nginx的代码必须可以跨平台编译运行，nginx选择了完全从头实现一遍基础的数据结构和算法,比如双向链表、动态数组、红黑树、 哈希表等，理解这些基础的数据结构和算法对于我们好处不言而
数据队列 Queue 的使用 （转）
edo_full的专栏
07-30 1441
数据队列 数据队列一般用于数据缓存，可以用来平衡速率不同的两个部件，使快速部件无需等待慢速部件。 数据队列一般是先入先出的，但本数据队列可以配置成后入先出。本数据队列是可配置可裁剪的模块，并且不依赖于操作系统，可以在前后台系统中使用。数据队列使用的空间由用户分配且由这个空间的地址唯一识别一个数据队列。 API函数 数据队列软件模块包括的API函数如下所示： API函数名
RT-Thread 隐藏的宝藏之 data_queue
whj123999的博客
02-27 2708
1. data_queue 是什么 data_queue 直接翻译过来是 数据队列。这个名字和 消息队列 很像。那么他们有什么区别呢？ 消息队列：消息队列能够接收来自线程或中断服务例程中不固定长度的消息，并把消息缓存在自己的内存空间中。其他线程也能够从消息队列中读取相应的消息，而当消息队列是空的时候，可以挂起读取线程。当有新的消息到达时，挂起的线程将被唤醒以接收并处理消息。消息队列是一种异步的通信方式。(摘自 RT-Thread文档中心). 数据队列：没有找到官方详细的说明，只是在 RT-Thread AP
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
【数据结构】栈和队列
最新发布
2301_81348661的博客
12-08 3739
然后，我们可以使用STTop取出栈(st)中的数据，进行对栈(s)的左右括号的匹配，如果匹配不成功，则返回false，直到栈(s)为空时，过程结束。若节点大于一个，那我们可以创建一个QNode*的next节点指向队头指向的下一个节点，然后再将队头的节点free，再重新将队头的节点改为next指针指向的新节点。首先，我们来了解一种新的数据结构——栈。将数据导入栈中，首先，将空间进行扩容（防止空间不足引起的越界访问）,并将扩容后的空间传给数组a，然后，再于新空间进行导入数据的操作，结尾记得改变新栈的个数。
[详解栈和队列]数据结构之栈与队列
Philosophy7的博客
05-12 4167
✅作者简介：大家好,我是Philosophy7？让我们一起共同进步吧！🏆 📃个人主页：Philosophy7的csdn博客 🔥系列专栏： 👑哲学语录: 承认自己的无知，乃是开启智慧的大门 💖如果觉得博主的文章还不错的话，请点赞👍+收藏⭐️+留言📝支持一下博>主哦🤞 文章目录栈和队列1.物理结构和逻辑结构2.什么是栈2.1栈的基本操作3.什么是队列队列的基本操作小结 栈和队列 1.物理结构和逻辑结构 再了解栈和队列之前，我们要先知道什么是逻辑结构和物理结构。 逻辑结构: 按照逻辑结构划分:数据结.
Data Queue
weixin_34138255的博客
10-21 858
更多内容请访问 www.uusystem.com AS400里临时存放数据的有file、data area和Data Queue,而处理速率由快到慢的是：Data Queue->Data area->File。所有MQ选择与Data Queue搭配使用。 1.当有message从System B发到System A时，System A这边的MQM会把MQ了的message放到Data...
队列queue的详细讲解
热门推荐
乐不思书的专栏
04-13 4万+
 一、Java  Queue基础 Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构 offer，add区别： 一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。 这时新的 offer 方法就可以起作用了。它不是对调用 add() 方法抛出一个 unchecked 异常，而只是得到由 offer() 返回的 false。 pol
Unity学习之C#数据结构_栈和队列__队列__顺序队列（循环顺序队列）
OJMars的博客
04-21 1297
这次介绍的是循环队列，介绍循环队列之前，先介绍一下队列的概念。队列（Queue）：入队（添加数据）操作限定在队尾（Rear），其他操作限定在队头(Front)的线性表，当队列中没有数据元素时称为空队列。 队列也有两种：顺序队列和链队列，他们区别是，顺序队列是用数组来储存数据的，但是链队列是用单个变量和引用来保存数据的，但是他们的处理数据的逻辑都是一样的，入队（添加数据）操作限定在队尾（Rear），...
C#数据结构和算法学习系列六----堆栈、堆栈的实现和应用
cxm52013144的博客
09-12 324
堆栈和队列是两种面向表的数据结构，它们都提供了易于理解的抽象。堆栈中的数据只能在表的某一端进行添加和删除操作，反之队列中的数据则在表的一端进行添加操作而在表的另一端进行删除操作。堆栈被广泛用于从表达式计算到处理函数调用的任何编程语言的实现中。而队列则用在区分优先次序的操作系统处理以及模拟现实世界的事件方面，比如银行出纳柜台的队列，以及建筑物内电梯的操作。C#语言为使用这些数据结构提供了两种类：S...
二叉树（数据结构）
mrhjlong
04-27 8488
树（Tree）是n(n >= 0)个结点的有限集合，n = 0 时称为空树。在任意一棵非空树中：(1)有且仅有一个特定的称为根(Root)的结点；(2)当n > 1 时，其余结点可分为m(m > 0)个互不相交的有限集T1,T2,……Tm，其中每个集合本身又是一棵树，并且称为根的子树(SubTree);注意两点：(1) 根节点是唯一的；(2) 子树互不相交。
json_object_object_foreach遍历json的宏定义实现
mrhjlong
10-30 4853
# define json_object_object_foreach(obj,key,val) \ char *key; struct json_object *val; \ for(struct lh_entry *entry = json_object_get_object(obj)-&gt;head; ({ if(entry) { key = (char*)entry-&gt;k; v...
排序、查找（数据结构）
mrhjlong
04-19 3219
一、排序算法 1、冒泡排序 思路：按照约定的排序顺序，两两比较相邻的数据，如果反序则交换，直到没有反序的记录为止。 算法复杂度：O(n^2) 比较次数：(1 + 2 + 3 +…+ n-1) = n * (n – 1) / 2 次 /************************************************************************* ...
链表（数据结构）- LRC歌词解析播放示例
mrhjlong
04-27 1050
链表与数组 链表和数组一样也是线性表的一种，所谓线性表是指零个或多个数据元素的序列，序列元素之间有明显的前驱后继关系。 但链表与数组不一样的是，链表是通过指针域串联起来的，而数组是通过一片连续的存储空间串联起来，数组元素的地址有着明显的线性关系，而链表元素地址之间则没有关系。使用数组需要预先分配一片连续的存储空间，而链表则可以无限制的加入新的结点。 本文将介绍通用单向链表、单向循环链表、双向链...
归并排序（代码）-递归方法
mrhjlong
04-23 622
merge函数：将数组从left（起始位置）到right（终点位置）的数据，先折半拆分为两组。分别从两组的起始数据开始进行比较，较小的值被保存，然后标志值增加（指针后移），直到将两组数据全都遍历一遍。将保存的数据依次按顺序覆盖写入数组a，作为输出流输出。 mergesort函数（归并排序）：利用递归的方法进行数组的拆分，调用merge函数，实现排序。 /* 将数组折半分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值