初学栈与队列

最新推荐文章于 2024-05-27 09:38:52 发布
最新推荐文章于 2024-05-27 09:38:52 发布
阅读量364 收藏 2
点赞数
分类专栏： 编程心得 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caterpillarous/article/details/48552173
版权
建立一个栈的基本流程为
首先定义栈的结构 包括栈的大小 指向栈顶和栈底的指针
1.使用malloc函数开辟一段连续的空间 使top=base=该空间的首地址
2.将数据压入（push）栈中  使用for循环 使得top=压入的数据 然后top+1 指向下一个空间
3.如果预留空间不够大 即(S->top - S->base) / sizeof(SElemType) >= S->size 用realloc函数重新分配即可

几个基本操作
1.栈的构造 见上
2.清空栈 使得top=base 于是下次push时又从头开始 也可以用if(s->top==s->base)来判断是否是空栈
3.判断栈是否满了 if((s->top-s->base)/sizeof(SElemType)==s->size)  那么该栈已满
4.进栈/压栈  见上
5.退栈 只需s->top-1 此时top指向栈顶的元素。
6.取栈顶元素。只是取出该元素，栈不能改变。*e = *(S.top - sizeof(SElemType))即可
7.销毁栈。根据构造栈时的代码 S->base = (SElemType*) malloc(INIT_SIZE * sizeof(SElemType))可知
栈的首地址为s->base 所以只需free(s->base)即可
此时如果再向栈中push数据，会发现仍然可以写入，这是因为top指针和base指针仍旧指向之前的那块地址，所以在销毁栈时，不仅要free(s->base)，还要使s->top=NULL;s->base=NULL.我借鉴的代码上最后还写了【s->size=0】 这段代码我认为是可有可无的 假如有大牛看到这里觉得不对 还请在评论里指点一二。


队列
我觉得栈就是线性表（顺序表），一次性分配一段连续的物理空间来储存
而队列则是单向链表的实现，队列的每个单元都是一个由数据与后继指针组成的结构体，它在物理空间上是不连续的
当然 栈和队列的实现不止于使用线性表 这里只是讨论这一种情况

队列每个元素的构成
首先队列是动态的所以不需要规定一个size，它需要队头指针和队尾指针，而且这两个指针都是一个由数据与指针组成的结构体。
具体代码如下
typedef struct QNode
{
    QElemType data;
    struct QNode *next;
}QNode, *QueuePtr;

typedef struct
{
    QueuePtr front;    //队头指针
    QueuePtr rear;    //队尾指针
}LinkQueue;


关于队列的基本操作
1.构造空队列
Q->front=Q->rear=malloc(sizeof(Qnode))
此时另前指针front->next=NULL
2.求出队列此时的长度
在子函数中定义一个p，一个计数用的i， 使它等于头指针 while(Q->rear!=p);i++;p=p->next;
3.销毁队列
代码如下
    while (Q->front)
    {
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
Q->rear指向离Q->front最近的结点，释放Q->front，Q->front又指向Q->rear即原本的Q->front->next 就是原本离front最近的结点
然后这样依次释放，直到队列被销毁。
4.清空队列
清空队列只需先销毁这个队列，再重新建立一个即可
5.判断是否为空
Q->front->next==NULL?
6.返回队头的元素（若队列不空）
int p=Q.front->next; *e=p->data;
7.插入队尾元素
    QueuePtr p = (QueuePtr) malloc(sizeof(QNode));
    if (!p)
    {
        exit(OVERFLOW);
    }
    p->data = e;
    p->next = NULL;
    Q->rear->next = p;
    Q->rear = p;
8.遍历队列
    QueuePtr p = Q.front->next;
    while (p)
    {
        visit(p->data);
        p = p->next;
    }
因为尾指针rear->next=NULL


OK 现在回顾一下队列的建立基本步骤
队列构成的基本步骤
1.开辟一个结构体（包含数据域和指针域），头指针与尾指针均指向它，并将该结构的指针设为空 NULL
2.要想队列中添加数据时，先开辟一个结构体p，将p的指针设为空，另front也就是此时的rear的指针指向p，再令rear=p；如此循环 即可不断插入数据扩大队列。
3.队列的销毁 清空  获取队列长度 都需要遍历队列。常用方法是
while(Q->front); 当队列存在时
while(p)
    {
        visit(p->data);
        p = p->next;
    }    因为最后一个结点的指针为空

    QueuePtr p = Q.front;
    while (Q.rear != p)
    {
        i++;
        p = p->next;
    } 从头指针一直到尾指针



这是我的第一篇 稍微有点技术含量的博客
写了自己对于 栈和队列的理解 虽然很浅 但是还是挺高兴的
最后附上栈与队列的代码


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

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define INIT_SIZE 20
#define INCREMENT_SIZE 5

typedef int SElemType;
typedef int Status;

/*
 * 存储结构
 */
typedef struct
{
    SElemType *base;    //栈尾指针
    SElemType *top;        //栈顶指针
    int size;            //栈的大小
}SqStack;

/*
 * 初始化栈
 */
Status InitStack(SqStack *S)
{
    S->base = (SElemType*) malloc(INIT_SIZE * sizeof(SElemType));
    if (!S->base)
    {
        exit(OVERFLOW);
    }
    S->top = S->base;
    S->size = INIT_SIZE;
    return OK;
}

/*
 * 销毁栈
 */
Status DestroyStack(SqStack *S)
{
    free(S->base);
    S->base = NULL;
    S->top = NULL;
    S->size = 0;
    return OK;
}

/*
 * 清空栈
 */
Status ClearStack(SqStack *S)
{
    S->top = S->base;
    return OK;
}

/*
 * 判断栈是否为空
 */
Status IsEmpty(SqStack S)
{
    if (S.top == S.base)
    {
        return TRUE;
    }
    else
        return FALSE;
}

/*
 * 获取栈的长度
 */
int GetLength(SqStack S)
{
    return (S.top - S.base) / sizeof(SElemType);
}


/*
 * 获取栈顶元素
 */
Status GetTop(SqStack S, SElemType *e)
{
    if (S.top > S.base)
    {
        *e = *(S.top - sizeof(SElemType));
        return OK;
    }
    else
    {
        return ERROR;
    }
}

/*
 * 压栈
 */
Status Push(SqStack *S, SElemType e)
{
    if ((S->top - S->base) / sizeof(SElemType) >= S->size)
    {
        S->base = (SElemType*) realloc(S->base, (S->size + INCREMENT_SIZE) * sizeof(SElemType));
        if (!S->base)
        {
            exit(OVERFLOW);
        }
        S->top = S->base + S->size * sizeof(SElemType);
        S->size += INCREMENT_SIZE;
    }
    *S->top = e;
    S->top += sizeof(SElemType);
    return OK;
}

/*
 * 退栈
 */
Status Pop(SqStack *S, SElemType *e)
{
    if (S->top == S->base)
    {
        return ERROR;
    }
    S->top -= sizeof(SElemType);
    *e = *S->top;
    return OK;
}

/*
 * 访问元素
 */
void visit(SElemType e)
{
    printf("%d ", e);
}

/*
 * 遍历栈
 */
Status TraverseStack(SqStack S, void (*visit)(SElemType))
{
    while (S.top > S.base)
    {
        visit(*S.base);
        S.base += sizeof(SElemType);
    }
    return OK;
}

int main()
{
    SqStack S;
    if (InitStack(&S))
    {
        SElemType e;
        int i;

        printf("init_success\n");

        if (IsEmpty(S))
        {
            printf("Stack is empty\n");
        }

        for (i = 0; i < 10; i++)
        {
            Push(&S, i);
        }

        GetTop(S, &e);
        printf("The first element is %d\n", e);

        printf("length is %d\n", GetLength(S));

        Pop(&S, &e);
        printf("Pop element is %d\n", e);

        TraverseStack(S, *visit);

        if (DestroyStack(&S))
        {
            printf("\ndestroy_success\n");
        }
    }
}





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

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2

typedef int QElemType;
typedef int Status;

/*
 * 存储结构
 */
typedef struct QNode
{
    QElemType data;
    struct QNode *next;
}QNode, *QueuePtr;

typedef struct
{
    QueuePtr front;    //队头指针
    QueuePtr rear;    //队尾指针
}LinkQueue;

/*
 * 初始化队列
 */
Status InitQueue(LinkQueue *Q)
{
    Q->front = Q->rear = (QueuePtr) malloc(sizeof(QNode));
    if (!Q->front)
    {
        exit(OVERFLOW);
    }
    Q->front->next = NULL;
    return OK;
}

/*
 * 销毁队列
 */
Status DestroyQueue(LinkQueue *Q)
{
    while (Q->front)
    {
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
    return OK;
}

/*
 * 清空队列
 */
Status ClearQueue(LinkQueue *Q)
{
    DestroyQueue(Q);
    InitQueue(Q);
}

/*
 * 判断队列是否为空
 */
Status IsEmpty(LinkQueue Q)
{
    if (Q.front->next == NULL)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

/*
 * 获取队列的长度
 */
int GetLength(LinkQueue Q)
{
    int i = 0;
    QueuePtr p = Q.front;
    while (Q.rear != p)
    {
        i++;
        p = p->next;
    }
    return i;
}

/*
 * 获取队头元素
 */
Status GetHead(LinkQueue Q, QElemType *e)
{
    QueuePtr p;
    if (Q.front == Q.rear)
    {
        return ERROR;
    }
    p = Q.front->next;
    *e = p->data;
    return OK;
}

/*
 * 入队
 */
Status EnQueue(LinkQueue *Q, QElemType e)
{
    QueuePtr p = (QueuePtr) malloc(sizeof(QNode));
    if (!p)
    {
        exit(OVERFLOW);
    }
    p->data = e;
    p->next = NULL;
    Q->rear->next = p;
    Q->rear = p;
    return OK;
}

/*
 * 出队
 */
Status DeQueue(LinkQueue *Q, QElemType *e)
{
    QueuePtr p;
    if (Q->front == Q->rear)
    {
        return ERROR;
    }
    p = Q->front->next;
    *e = p->data;
    Q->front->next = p->next;
    if (Q->rear == p)
    {
        Q->rear = Q->front;
    }
    free(p);
    return OK;
}

/*
 * 访问元素
 */
void visit(QElemType e)
{
    printf("%d ", e);
}

/*
 * 遍历队列
 */
Status TraverseQueue(LinkQueue Q, void (*visit)(QElemType))
{
    QueuePtr p = Q.front->next;
    while (p)
    {
        visit(p->data);
        p = p->next;
    }
    return OK;
}

int main()
{
    LinkQueue Q;
    if (InitQueue(&Q))
    {
        QElemType e;
        int i;

        printf("init_success\n");

        if (IsEmpty(Q))
        {
            printf("queue is empty\n");
        }

        for (i = 0; i < 10; i++)
        {
            EnQueue(&Q, i);
        }

        GetHead(Q, &e);
        printf("The first element is %d\n", e);

        printf("length is %d\n", GetLength(Q));

        DeQueue(&Q, &e);
        printf("delete element is %d\n", e);

        TraverseQueue(Q, *visit);

        if (DestroyQueue(&Q))
        {
            printf("\ndestroy_success\n");
        }
    }
}

caterpillarous
关注
专栏目录
Head First 栈与队列
CocoaChen
09-17 1389
目录 一、前言 二、LIFO——栈 1、栈的概述 2、栈的基本算法
数据结构学习笔记（六）-- 栈的顺序结构
Qin_xian_shen的博客
09-22 245
#include #include #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define INIT_SIZE 20 #define INCREMENT_SIZE 5 typedef int SElemType; typedef int Status; /* * 存储
【数据结构】栈和队列超详细讲解
最新发布
Become Mad的博客
05-27 2111
我们已经学习了顺序表、链表、数组等数据结构，今天我们再来认识一下栈和队列两种新的数据结构，一起来看看吧~
【数据结构与算法】栈和队列
Jeloys的博客
01-14 684
栈的定义 栈是一种重要的线性结构，可以这样说，栈是前面将国的线性表的一种具体形式。 栈是后进先出的数据结构，它要求只在表尾进行删除和插入操作。 所谓的栈其实就是一个特殊的线性表（顺序表、链表），但是它在操作上有一些特殊的要求和限制： 栈的元素必须（后进先出） 栈的操作只能够在这个线性表的表尾进行 注意：对于栈来说，这个表尾称为栈的栈顶（top），相应的表头称为栈底（buttom）。 栈...
[算法] 栈和队列
m0_46708851的博客
04-06 2212
总结了力扣上栈和队列部分的常见题型，包含模板方法，欢迎阅读。
栈和队列的基本操作
qq_62509159的博客
12-15 1195
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录​​​ 1.栈 2.队列 一、简单介绍栈和队列 1.栈：栈(stack)是限定仅在表尾进行插入或者删除的线性表，表尾被成为栈顶，表头被称为栈底。对于栈来说，对他只能在栈顶进行操作。所以，栈又被称为先进后出的线性表。 2.队列：队列只允许在队列的头进行删除操作，在队列的尾进行插入操作。特点是：先进先出、 二、题目练习 冰冰子...
数据结构基础之栈与队列
lankuohsing的博客
09-09 156
文章目录1. Java中的栈Stack1.1. Stack的应用之括号匹配2. Java中的队列Queue 1. Java中的栈Stack 栈是Vector的一个子类，它实现了一个标准的后进先出的栈。 序号 方法描述 1 boolean empty()测试堆栈是否为空。 2 Object peek( )查看堆栈顶部的对象，但不从堆栈中移除它。 3 Object pop( )移除堆栈顶部的对象，并作为此函数的值返回该对象。 4 Object push(Object element.
C++栈和队列
谙忆-陈浩翔
08-28 2957
使用标准库的栈和队列时，先包含相关的头文件#include<stack> #include<queue>定义栈如下：stack<int> stk;定义队列如下：queue<int> q;栈提供了如下的操作s.empty() 如果栈为空返回true，否则返回false s.size() 返回栈中元素的个数 s.pop()
纯c语言模拟栈和队列（初学必看）
稻草人敲代码的博客
11-13 887
栈是一种特殊的线性表，在栈这个结构里，越先存进去的数据越难取出来。这个结构就像是一个只有一端有打开的容器，越先放进去的球越在底部，想要把底部的球拿出来，就必须先把前面的求拿出来。像这种”先进后出“的结构就是栈。对于栈来说，我们只能在表尾进行插入或者删除，表。
C语言实现栈与队列
05-17
在IT领域，数据结构是编程基础中的重要组成部分，而栈（Stack）和队列（Queue）是最基础且广泛使用的两种数据结构。本项目是用C语言实现的栈和队列，提供了可加载和使用的源代码，这对于理解这两种数据结构的工作...
huiw.dsp.rar_回文栈和队列_用栈和队列编写判断回文的c语言程序
09-24
在编程中，判断一个字符串是否为回文通常会涉及到数据结构的运用，栈和队列就是其中两种常用的数据结构。在这个名为“huiw.dsp.rar”的压缩包中，包含了一个使用C语言编写的程序，该程序利用栈和队列来判断一个字符...
线性结构- 栈与队列.rar
09-16
线性结构是计算机科学中数据组织的基本形式之一，它包括一系列元素，这些元素按照特定的顺序排列。...无论是数据结构的初学者还是经验丰富的开发者，对栈和队列的理解都将对解决问题提供极大的帮助。
数据结构栈和队列解决迷宫问题
06-07
本文档详细介绍了利用栈和队列解决迷宫问题的步骤，对于初学者学习数据结构能很好的进行辅导。本文档主要涉及到数据结构的两个重要概念：栈和队列，并介绍了如何使用这两个数据结构来解决迷宫问题。 一、栈的基本...
栈与队列ppt及代码
09-12
本资料包“栈与队列ppt及代码”提供了关于这两种数据结构的深入理解，包括它们的概念、实现方式以及在实际问题中的应用，特别适合准备面试或提升编程技能的IT从业者。 首先，栈（Stack）是一种后进先出（LIFO，Last...
60行Shell代码实现在命令行中优雅地听歌
热门推荐
caterpillarous的博客
04-24 1万+
本文也发在了我的新个人博客上了，可以点击下面的链接获取更好的阅读体验： 60行Shell代码实现在命令行中优雅地听歌 0. 起因 起因就是对探索新歌失去了兴趣，并且觉得各种音乐播放软件都不怎么好用，而且懒癌发作，觉得写代码的时候想要换歌还要切换到音乐播放器再切回来实在太烦了。于是我把自己喜欢听的歌都下载下来了，放到一个文件夹里，准备用终端播放。整个过程非常简单，我所需要的只是一个想法...
一个爬进正方教务系统的爬虫的诞生
caterpillarous的博客
10-25 6779
我的新博客地址： http://jujuba.me/ 0x00. 准备工作工具：chromepython一些python库，主要是requests要想爬进教务系统，首先要知道教务系统的网址对吧。这边可以看到网址是http://jwgl.bistu.edu.cn。但是，机智的人都会发现，当你将这个url输入地址栏并按下回车时，网址变了，变成了形如http://jwgl.bistu.edu.cn/(d...
反向代理+负载均衡部署javaWeb项目
caterpillarous的博客
10-25 2761
本博客已经弃用，我的新博客地址：http://jujuba.me/ 准备四台虚拟机(Ubuntu14.04)建议后台服务器与数据库服务器用server版加winSCP或Xshell辅助就ok，没必要上desktop版的负载均衡器 * 1搭载apache后台服务器 * 2搭载tomcat并部署项目（建议通过官网安装包下载，不建议apt-get安装）安装java8 （后文有提及）安装mysql数据库服...
数据结构之——用C++实现邻接表的DFS与BFS
caterpillarous的博客
12-19 2115
首先我们要知道邻接表的基本思想： 邻接表存储的基本思想：对于图的每个顶点vi，将所有邻接于vi的顶点链成一个单链表，称为顶点vertex的边表（对于有向图则称为出边表），所有边表的头指针和存储顶点信息的一维数组构成了顶点表。 在这里我打算将一个无向图的邻接表的建立，以及相应的深度优先搜索和广度优先搜索 首先我们要明白一个邻接表是什么样的，看下面这个图： 这是一个无向图，与之对应
栈与队列详解：数据结构基础
"数据结构中的栈和队列是两种重要的线性数据结构，适用于初学者。本课件详细讲解了栈和队列的概念、类型定义、应用实例以及它们的实现方式。" 在计算机科学中，数据结构是组织和管理数据的方式，而栈和队列是其中最...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值