详解栈与顺序栈

最新推荐文章于 2024-08-26 23:00:00 发布
最新推荐文章于 2024-08-26 23:00:00 发布
阅读量96 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjwjn/article/details/133934192
版权

目录

1.栈的定义

2.顺序栈

3.顺序栈的实现

 4.完整的Demo

5.小结 

6.参考文献

 

1.栈的定义

栈（stack）又被称为堆栈，它是一种只允许在一端（一般是表尾）进行插入和删除操作的线性表。

允许进行操作的一端称为“栈顶”；
另一端称为“栈底”；
当栈中没有元素时称为“空栈”；
栈是一个特殊的线性表；
特点:后进先出(LIFO)；

2.顺序栈

顺序栈是栈的顺序实现。顺序栈是指利用顺序存储结构实现的栈。采用月地址连续的存储空间(数组)依次存储栈中数据元素，由于入栈和出栈运算都是在栈顶进行，而栈底位置是固定不变的，可以将栈底位置设置在数组空间的起始处;栈顶位置是随入栈和出栈操作而变化的，故需用一个整型变量top来记录当前栈顶元素在数组中的位置。

运算概述：初始化，入栈，出栈，获取栈顶元素和判断栈是否为空或为满与销毁

3.顺序栈的实现

1.初始化

int init(SeqStack *S, int MaxSize) {
    /*申请内存空间*/
    S->data = (DataType *) malloc(sizeof(DataType) * MaxSize);

    if (!S->data) {
        printf("内存申请错误，初始化失败！[10001]\n");
        return 10001;
    }
    S->maxsize = MaxSize;
    S->top = -1;
    return 0;
}

执行结果:

 

2.入栈

int push(SeqStack *S, DataType x) {
    /*是否满？*/
    if (full(S)) {
        printf("栈已满！10002\n");
        return 10002;
    }

    S->top++;            /*移动指针*/
    S->data[S->top] = x;/*放入数据*/
    return 0; /*OK*/
}

执行结果：

 

3.出栈

int pop(SeqStack *S, DataType *x) {
    /*是否空？*/
    if (empty(S)) {
        printf("栈为空！10003\n");
        return 10003;
    }

    *x = S->data[S->top];    /*栈顶元素赋值给x*/
    S->top--;                /*移动栈顶指针*/
    return 0;
}

执行结果：

 

 

 4.取栈顶元素

int get_top(SeqStack *S, DataType *x) {
    /*是否空？*/
    if (empty(S)) {
        printf("栈为空！10003\n");
        return 10003;
    }

    *x = S->data[S->top];    /*栈顶元素赋值给x*/

    return 0;
}

执行结果：

 

5.栈是否为空

int empty(SeqStack *S) {
    return (S->top == -1) ? 1 : 0;
}

执行结果：

 

6.栈是否为满 

int full(SeqStack *S) {
    return (S->top == S->maxsize - 1) ? 1 : 0;
}

执行结果：

 

7.销毁

int destroy(SeqStack *S) {
    free(S->data);
    return 0;
}

 执行结果：

 8.栈的应用——十进制转化为二进制

int d_to_b(int d) {
    SeqStack S;
    int b;

    /*初始化栈*/
    init(&S, 32);

    /*d不为0，余数进栈*/
    while (d) {
        push(&S, d % 2);
        d /= 2;
    }

    /*依次出栈*/
    while (!empty(&S)) {
        pop(&S, &b);
        printf("%d", b);
    }

    /*销毁栈*/
    destroy(&S);
}

9.栈的应用——后缀表达式的计算

void expression() {
    SeqStack S;
    int i,op1, op2,x;

    char exp[20]; /*后缀表达式*/

    init(&S, 10);

    printf("请输入一个后缀表达式(eg. 56+):");
    scanf("%s", exp);

    for (i = 0; i < strlen(exp); i++) {
        switch (exp[i]) {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                /*入栈*/
                push(&S, exp[i] - 48);
                break;
            case '+':
                /*出2个*/
                pop(&S, &op1);
                pop(&S, &op2);
                x = op2 + op1;
                push(&S, x);
                break;

            case '*':
                pop(&S, &op1);
                pop(&S, &op2);
                x = op2 * op1;
                push(&S, x);
                break;
            case '-':
                pop(&S, &op1);
                pop(&S, &op2);
                x = op2 - op1;
                push(&S, x);
                break;
            case '/':
                pop(&S, &op1);
                pop(&S, &op2);
                x = op2 / op1;
                push(&S, x);
                break;
        }
    }
    pop(&S, &x);
    printf("计算结果为：%s = %d\n", exp, x);
    destroy(&S);
}

执行结果：

 4.完整的Demo

 1.main.c

#include <stdio.h>
#include "seqstack.c"


int main(int argc, char *argv[]) {

    SeqStack S;
    int cmd,d,maxsize;
    DataType x;
    char yn;

    do {
        printf("---------顺序栈演示程序-----------\n");
        printf(" 1. 初始化\n");
        printf(" 2. 入栈\n");
        printf(" 3. 出栈\n");
        printf(" 4. 取栈顶元素\n");
        printf(" 5. 栈是否空？\n");
        printf(" 6. 栈是否满？\n");
        printf(" 7. 销毁栈\n");
        printf(" 8. 栈的应用\n");
        printf("请选择（0~9,0退出)：");
        scanf("%d", &cmd);
        switch (cmd) {
            case 1:
                printf("请输入栈的最大存储空间(MaxSize)：");
                scanf("%d", &maxsize);
                if (!init(&S, maxsize)) {
                    printf("栈已初始化！\n");
                }
                break;
            case 2:
                printf("请输入入栈元素：x=");
                scanf("%d", &x);
                if (!push(&S, x)) {
                    printf("元素【%d】已入栈！\n", x);

                }
                break;
            case 3:
                printf("确定要出栈（出栈后数据不可恢复,y|n,n）？");
                fflush(stdin);
                scanf("%c", &yn);
                if (yn == 'y' || yn == 'Y') {
                    if (!pop(&S, &x)) {
                        printf("栈顶元素【%d】已出栈！\n", x);
                    }
                }

                break;
            case 4:
                if (!get_top(&S, &x)) {
                    printf("栈顶元素为：%d\n", x);
                }
                break;
            case 5:
                if (empty(&S)) {
                    printf("栈为空！\n");
                } else {
                    printf("栈不为空！\n");
                }
                break;
            case 6:
                if (full(&S)) {
                    printf("栈已满！\n");
                } else {
                    printf("栈未满！\n");
                }
                break;
            case 7:
                printf("确定要销毁（销毁后数据不可恢复,y|n,n）？");

                fflush(stdin);//  清空输入stdin缓冲区

                scanf("%c", &yn);
                if (yn == 'y' || yn == 'Y') {
                    if (!destroy(&S)) {
                        printf("销毁栈成功！\n");
                    }
                }
                break;
            case 8:
                do {
                    printf("----------8.栈的应用------------\n");
                    printf(" 1. 十进制转换为二进制\n");
                    printf(" 2. 后缀表达式计算\n");
                    printf(" 0. 返回\n");
                    printf("请选择：");
                    scanf("%d", &cmd);

                    if (cmd == 1) {
                        printf("请输入一个十进制数：");
                        scanf("%d", &d);
                        printf("二进制为：");
                        d_to_b(d);
                        printf("\n");
                    }

                    if (cmd == 2) {
                        expression();
                    }
                } while (cmd != 0);
                cmd = -1;
                break;
        }

    } while (cmd != 0);

    return 0;
}

 2.seqstack.c

#include <stdio.h>
#include <malloc.h>
#include "seqstack.h"
#include <string.h>


/* 1. 初始化 */
int init(SeqStack *S, int MaxSize) {
    /*申请内存空间*/
    S->data = (DataType *) malloc(sizeof(DataType) * MaxSize);

    if (!S->data) {
        printf("内存申请错误，初始化失败！[10001]\n");
        return 10001;
    }
    S->maxsize = MaxSize;
    S->top = -1;
    return 0;
}


/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x) {
    /*是否满？*/
    if (full(S)) {
        printf("栈已满！10002\n");
        return 10002;
    }

    S->top++;            /*移动指针*/
    S->data[S->top] = x;/*放入数据*/
    return 0; /*OK*/
}

/* 3. 出栈 */
int pop(SeqStack *S, DataType *x) {
    /*是否空？*/
    if (empty(S)) {
        printf("栈为空！10003\n");
        return 10003;
    }

    *x = S->data[S->top];    /*栈顶元素赋值给x*/
    S->top--;                /*移动栈顶指针*/
    return 0;
}

/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x) {
    /*是否空？*/
    if (empty(S)) {
        printf("栈为空！10003\n");
        return 10003;
    }

    *x = S->data[S->top];    /*栈顶元素赋值给x*/

    return 0;
}

/* 5. 栈为空？*/
int empty(SeqStack *S) {
    return (S->top == -1) ? 1 : 0;
}

/* 6. 栈满？*/
int full(SeqStack *S) {
    return (S->top == S->maxsize - 1) ? 1 : 0;
}


/* 7. 销毁*/
int destroy(SeqStack *S) {
    free(S->data);
    return 0;
}




/*十进制转换为二进制*/
int d_to_b(int d) {
    SeqStack S;
    int b;

    /*初始化栈*/
    init(&S, 32);

    /*d不为0，余数进栈*/
    while (d) {
        push(&S, d % 2);
        d /= 2;
    }

    /*依次出栈*/
    while (!empty(&S)) {
        pop(&S, &b);
        printf("%d", b);
    }

    /*销毁栈*/
    destroy(&S);
}

/*后缀表达式计算*/
void expression() {
    SeqStack S;
    int i,op1, op2,x;

    char exp[20]; /*后缀表达式*/

    init(&S, 10);

    printf("请输入一个后缀表达式(eg. 56+):");
    scanf("%s", exp);

    for (i = 0; i < strlen(exp); i++) {
        switch (exp[i]) {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                /*入栈*/
                push(&S, exp[i] - 48);
                break;
            case '+':
                /*出2个*/
                pop(&S, &op1);
                pop(&S, &op2);
                x = op2 + op1;
                push(&S, x);
                break;

            case '*':
                pop(&S, &op1);
                pop(&S, &op2);
                x = op2 * op1;
                push(&S, x);
                break;
            case '-':
                pop(&S, &op1);
                pop(&S, &op2);
                x = op2 - op1;
                push(&S, x);
                break;
            case '/':
                pop(&S, &op1);
                pop(&S, &op2);
                x = op2 / op1;
                push(&S, x);
                break;
        }
    }
    pop(&S, &x);
    printf("计算结果为：%s = %d\n", exp, x);
    destroy(&S);
}

3.seqstack.h

typedef int DataType;


typedef struct
{
	DataType *data; /* 堆空间 */
	int maxsize;
	int top;		/* 栈顶指针 */
}SeqStack;


/* 1. 初始化 */
int init(SeqStack *S, int MaxSize);

/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x);

/* 3. 出栈 */
int pop(SeqStack *S, DataType *x);

/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x);

/* 5. 栈为空？*/
int empty(SeqStack *S);

/* 6. 栈满？*/
int full(SeqStack *S);

/* 7. 销毁*/
int destroy(SeqStack *S);

/*十进制转换为二进制*/
int d_to_b(int d);

/*后缀表达式计算*/
void expression();

5.小结 

顺序栈是数据结构中比较基础的一种数据结构，它是一种线性数据结构。采用先进后出的原则，类似于箱子叠放，后进的箱子需要先取出来，这就是顺序栈的特点。在学习顺序栈的过程中，掌握了顺序栈的创建、入栈、出栈等基本操作，同时也深刻理解了顺序栈数据结构的特性。

6.参考文献

《数据结构（c语言版）》李刚 刘万辉

zjwjn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
堆栈计算机的原理和实现
Forth语言编程专栏
03-07 2万+
堆栈计算机的原理和实现 原书《 Stack Computers: the new wave 》 （原书封面） 原作者 Philip J. Koopman, Jr. 编译者 赵宇 张文翠 这是第一本讨论新一代堆栈计算机的书，而实现这种体系结构的第一块芯片是 Novix 公司的NC4016芯片。本书作者从堆栈如何被用于计算开始，对过去和现在大约 70 多个堆栈计算机进行分类，并对其中的7个堆栈计算机进
关于堆栈的论文
08-18
是一篇关于数据堆栈的研讨性论文,主要论述了堆栈过程的原理和一些应用。
浅谈计算机基础知识（三）
CJ130923的博客
10-09 1065
三 程序 = 数据结构 + 算法 数据结构基本概念 数据的逻辑结构：反映数据元素之间的关系的数据元素集合的表示。数据的逻辑结构包括集合、线形结构、树形结构和图形结构四种。 数据的存储结构：数据的逻辑结构在计算机存储空间种的存放形式称为数据的存储结构。常用的存储结构有顺序、链接、索引等存储结构。 插入和删除是对数据结构的两种基本操作。此外还有查找、分类、合并、分解、复制和修改等。 四种线性结...
堆栈学习总结
schamman的专栏
10-09 618
一：栈(stack) 函数调用之前会将当前存入到栈中。程序中栈是由编译器管理。 入栈，栈指针减小 出栈，栈指针增大 栈遵守先入后出原则 栈只有唯一入口，即栈指针。而堆可以有多个入口。     在函数中，参数和自动变量都将送入栈区。   函数退出后，属于该函数的
内存模型之参考文献
qiaofeiw的专栏
03-15 880
前两篇文章，希望大家多多带着怀疑的态度来读，很有可能有错误。:) 如果想进一步了解，可以看如下文献： 1. Shared Memory Consistency Models: A Tutorial http://www.cs.utexas.edu/users/dburger/teaching/cs382m-f06/papers/16paper.pdf Sarita Advey和Ko
栈——顺序栈
蜗小牛的博客
10-10 2万+
栈——顺序栈栈的定义栈的表示和实现顺序栈的定义顺序栈的模块说明栈基本操作部分算法描述 栈的定义 栈：是限定仅在表尾进行插入和删除操作的线性表，又称为后进先出的线性表（简称LIFO结构）。 栈顶：线性表的表尾。 栈底：线性表的表头。 空栈：不含元素的栈。 栈的表示和实现 和线性表类似，栈也有两种存储表示方法：顺序栈和链栈。 顺序栈：栈的顺序存储结构是利用一组地址连续的存储单元依次存放自栈底到栈顶的数...
LwIP协议栈的设计与实现-中文 与 LwIP协议栈源码详解
03-20
LwIP协议栈源码详解.pdf 和 LwIP协议栈的设计与实现_中文译稿.pdf 这两个文档很可能是深入分析LwIP源代码和设计原理的教程。它们可能涵盖了以下内容： 1. LwIP的架构和工作流程：详细解释各个模块的功能和交互方式...
LwIP协议栈源码详解_LwIP_协议栈详解_
09-29
**LwIP协议栈源码详解** LwIP（Lightweight TCP/IP）是一个开源的、轻量级的网络协议栈，适用于嵌入式系统。它由瑞典Chalmers大学的Adiscon公司开发，旨在为资源有限的微控制器提供TCP/IP功能。LwIP在设计时考虑了...
C语言栈的表示与实现实例详解
09-04
栈在C语言中的表示通常使用数组或链表实现，这里我们将主要关注基于数组的顺序栈。 1. 基本概念： 栈是一种线性数据结构，其特点是只允许在表的一端，也就是栈顶进行插入（Push）和删除（Pop）操作。栈底是固定的，...
栈的四则运算实现及详解
05-15
### 栈的四则运算实现及详解 #### 一、引言 在计算机科学中，栈是一种非常重要的数据结构，其遵循后进先出（LIFO, Last In First Out）的原则。栈通常用于解决需要“回溯”的问题，例如函数调用栈、括号匹配等问题...
堆栈的概念
程序猿养成记
10-20 936
堆栈都是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。在单片机应用中，堆栈是个特殊的存储区，主要功能是暂时存放数据和地址，通常用来保护断点和现场。要点：堆，队列优先,先进先出（FIFO—first in first out）。栈，先进后出(FILO—First-In/Last-Out)。 堆栈空间分配  栈（操作系统）：由操作系统自动分配释放 ，存放
计算机组成原理堆栈的概念,计算机组成原理堆栈.doc
weixin_39748773的博客
07-15 725
计算机组成原理堆栈摘 要堆栈是计算机系统中的一个重要概念，也是理解微型计算机组成的一个基础概念。?目 录一. 任务解析………………………………………………………………….3二. 系统方案论证…………………………………………………………….32.1总体方案与比较论证…………….………………………………….32.2 设计思路…………………………………………………………….42.3系统原理与结构……...
顺序栈基本操作（入栈和出栈）C语言详解
数据结构和算法教程（C语言版）
03-14 1万+
顺序栈，即用顺序表实现栈存储结构。通过前面的学习我们知道，使用栈存储结构操作数据元素必须遵守 "先进后出" 的原则，本节就 "如何使用顺序表模拟栈以及实现对栈中数据的基本操作（出栈和入栈）" 给大家做详细介绍。 如果你仔细观察顺序表（底层实现是数组）和栈结构就会发现，它们存储数据的方式高度相似，只不过栈对数据的存取过程有特殊的限制，而顺序表没有。 例如，我们先使用顺序表（a 数组）存储{1,2,...
数据结构——栈（顺序栈）
qq_39628738的博客
03-11 3540
栈的概念：只能在表尾进行插入（入栈）和删除（出栈）的数据结构（受到限制的线性表）。 表尾比较特殊，我们一般把这个表尾叫做栈顶，另一端栈底。没有数据节点，则叫做空栈 特点：先进后出（FILO）a1最先进栈，a1最后出栈。 为了更好的理解，可以想象生活中的例子：子弹弹夹 直接给出栈的结构体定义：（结构体中需要三个成员） #define INIT_SIZE 10 typedef int ELEM_TYPE; typedef struct Stack { ELEM_TYPE* base;//一个
顺序栈——9种基本操作和实现（C语言）
热门推荐
69小石头的博客
11-29 4万+
栈是仅限定在表尾进行插入和删除操作的线性表，九种栈的基本操作；分别是构造 销毁 清空 栈长 栈顶 插入 删除 遍历。下面就是代码实现： //头文件 #include<stdio.h> #include<string.h> #include<stdlib.h> #include<malloc.h> //宏定义 #define TRU...
顺序栈/链式栈
sandmm112的博客
04-09 1万+
        栈是是一种限定性的线性表，它将线性表的插入和删除限定为仅在表的一端进行。将表中允许插入和删除的一端成为栈顶。所以栈顶的位置是不断动态变化的。它具有“后进先出”的特点。因为栈是由线性表实现的，所以，栈有两种存储结构：顺序存储和链式存储。对应的栈成为顺序栈和链式栈。下面，分别来介绍这两种栈的相关操作。一，顺序栈        它与顺序表类似，即用一组地址连续的空间存放栈中的元素。之前的...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 4690
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
最新发布
Loewen丶的小窝
08-26 4786
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
顺序栈与动态存储实现详解
本资源主要介绍了栈的两种存储结构——顺序栈，它是数据结构课程中的重要内容。栈是一种具有特殊操作限制的线性表，其特点是只允许在一端（栈顶）进行插入或删除操作，遵循先进后出（FILO）或后进先出（LIFO）原则。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值