队列、栈（数据结构）

最新推荐文章于 2021-06-28 19:44:42 发布
最新推荐文章于 2021-06-28 19:44:42 发布
阅读量290 收藏
点赞数
分类专栏： 数据结构 文章标签： 栈 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrhjlong/article/details/80102129
版权

介绍

  • 队列是一种先进先出（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;
}
j衣l日
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构（栈、队列）
qq_42462016的博客
06-16 154
栈和队列基操一、栈1.顺序栈数据定义初始化入栈出栈取栈顶求栈长判空清空销毁2.链栈数据定义初始化入栈出栈取栈顶判空清空销毁二、队列1.顺序队列数据定义队列初始化入队出队取队头取队尾队长清空判空销毁2.链式队列数据定义初始化入队出队取队首元素取队尾元素判空清空销毁 一、栈 1.顺序栈 数据定义 //顺序栈数据结构 typedef struct SNode{ int *top;//栈顶指针 int *base;//栈底指针 int stackSize;//栈空间大小 int size; //元素个数 }SNod
数据结构 栈、队列
wangshiheyuanfang的博客
11-20 470
栈 后进先出线性表，是限制在表的一端进行插入或者删除操作，每次出栈的元素都是栈顶所在的元素，也就是最后进栈元素。按照存储方式，栈分为顺序栈和链式栈，顺序栈一般是由一维数组和栈顶变量组成，链式栈不会出现满栈溢出的情况。 队列 先进先出线性表，它的所有插入操作（入队）在一端，而删除操作（出队）在队列另一端。 循环队列个数=（队尾-对头+数组大小）mod 数组大小 不调用库函数实现st
C#数据结构和算法学习系列六----堆栈、堆栈的实现和应用
cxm52013144的博客
09-12 231
堆栈和队列是两种面向表的数据结构，它们都提供了易于理解的抽象。堆栈中的数据只能在表的某一端进行添加和删除操作，反之队列中的数据则在表的一端进行添加操作而在表的另一端进行删除操作。堆栈被广泛用于从表达式计算到处理函数调用的任何编程语言的实现中。而队列则用在区分优先次序的操作系统处理以及模拟现实世界的事件方面，比如银行出纳柜台的队列，以及建筑物内电梯的操作。C#语言为使用这些数据结构提供了两种类：S...
Data Queue
weixin_34138255的博客
10-21 727
更多内容请访问 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...
nginx 源码学习(四) 基本数据结构 ngx_queue_t
Daniel 的技术笔记 不积跬步无以至千里，不积小流无以成江海。
02-09 5512
nginx 队列结构 ngx_queue_t  介绍 由于nginx 具有跨平台及C语言实现的特点，使nginx不宜使用一些第三方中间件提供的容器和算法，跨平台(linux,windows等)的特点， 因此nginx的代码必须可以跨平台编译运行，nginx选择了完全从头实现一遍基础的数据结构和算法,比如双向链表、动态数组、红黑树、 哈希表等，理解这些基础的数据结构和算法对于我们好处不言而
数据队列 Queue 的使用 （转）
edo_full的专栏
07-30 1269
数据队列 数据队列一般用于数据缓存，可以用来平衡速率不同的两个部件，使快速部件无需等待慢速部件。 数据队列一般是先入先出的，但本数据队列可以配置成后入先出。本数据队列是可配置可裁剪的模块，并且不依赖于操作系统，可以在前后台系统中使用。数据队列使用的空间由用户分配且由这个空间的地址唯一识别一个数据队列。 API函数 数据队列软件模块包括的API函数如下所示： API函数名
C 语言通用模板队列（宏函数）
大橙子的博客
06-28 790
使用宏定义函数实现 C 语言队列的功能
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
数组、链表、队列、栈数据结构特点，各自优点和缺点 数组和链表.pdf
04-18
数组、链表、队列、栈数据结构特点，各自优点和缺点 在计算机科学中，数据结构是指用于组织和存储数据的方式。常见的数据结构包括数组、链表、队列、栈等。每种数据结构都有其特点、优点和缺点，本文将对这些数据...
Python 实现数据结构中的的栈队列
09-19
栈和队列是两种基本且常用的数据结构，它们在Python中有着多种实现方式。本篇文章将详细探讨如何使用Python来实现这些数据结构。 首先，栈（Stack）是一种后进先出（LIFO, Last In First Out）的数据结构，它遵循...
队列实现栈_栈_数据结构_队列_
09-30
栈和队列是两种基本且常用的数据结构，它们各有各的特点和应用场景。本篇将重点讨论如何利用队列来实现栈的功能，以及这两种数据结构在实际问题中的应用。 栈是一种后进先出（LIFO，Last In First Out）的数据结构...
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
队列queue的详细讲解
热门推荐
乐不思书的专栏
04-13 4万+
 一、Java  Queue基础 Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构 offer，add区别： 一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。 这时新的 offer 方法就可以起作用了。它不是对调用 add() 方法抛出一个 unchecked 异常，而只是得到由 offer() 返回的 false。 pol
二叉树（数据结构）
mrhjlong
04-27 8296
树（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 4473
# 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 2891
一、排序算法 1、冒泡排序 思路：按照约定的排序顺序，两两比较相邻的数据，如果反序则交换，直到没有反序的记录为止。 算法复杂度：O(n^2) 比较次数：(1 + 2 + 3 +…+ n-1) = n * (n – 1) / 2 次 /************************************************************************* ...
链表（数据结构）- LRC歌词解析播放示例
mrhjlong
04-27 899
链表与数组 链表和数组一样也是线性表的一种，所谓线性表是指零个或多个数据元素的序列，序列元素之间有明显的前驱后继关系。 但链表与数组不一样的是，链表是通过指针域串联起来的，而数组是通过一片连续的存储空间串联起来，数组元素的地址有着明显的线性关系，而链表元素地址之间则没有关系。使用数组需要预先分配一片连续的存储空间，而链表则可以无限制的加入新的结点。 本文将介绍通用单向链表、单向循环链表、双向链...
归并排序（代码）-递归方法
mrhjlong
04-23 501
merge函数：将数组从left（起始位置）到right（终点位置）的数据，先折半拆分为两组。分别从两组的起始数据开始进行比较，较小的值被保存，然后标志值增加（指针后移），直到将两组数据全都遍历一遍。将保存的数据依次按顺序覆盖写入数组a，作为输出流输出。 mergesort函数（归并排序）：利用递归的方法进行数组的拆分，调用merge函数，实现排序。 /* 将数组折半分...
栈与队列详解：数据结构基础
"数据结构中的栈和队列是两种重要的线性数据结构，适用于初学者。本课件详细讲解了栈和队列的概念、类型定义、应用实例以及它们的实现方式。" 在计算机科学中，数据结构是组织和管理数据的方式，而栈和队列是其中最...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值