数据结构-顺序栈

最新推荐文章于 2024-06-11 17:01:33 发布
最新推荐文章于 2024-06-11 17:01:33 发布
阅读量38 收藏
点赞数
文章标签： 数据结构 开发语言 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58138249/article/details/133960476
版权

1.顺序栈的定义

1.1 在了解顺序栈之前，我们要先知道栈是什么。

操作受限的线性表，限定仅在表尾进行插入和删除操作的线性表，即后进先出。这一端被称为栈顶，相对地，把另一端称为栈底。

栈的特点;

① 后进先出LIFO。

② 类比：洗碗盘子 子弹弹夹子弹出列。

1.2 顺序栈

用顺序结构存储的栈。

是限定仅在表尾进行插人或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶，相应地，表头端称为栈底。不含元素的空表称为空栈。栈的修改是按后进先出的原则进行的，因此栈又称为后进先出的线性表，简称LIFO结构。而顺序栈就是使用顺序结构来实现栈，顺序栈的空间是连续分配的。

2.顺序栈的基本运算

顺序栈的6种基本运算如下：

①初始化为栈空 InitStack(S):初始化操作，构造一个空栈。

②进栈操作 Push (S，x):进栈操作。在栈的顶部插入一个新元素x。

③出栈操作 Pop (S):出栈操作。删除栈顶端元素，并返回该元素。

④取栈顶元素 StackTop(S):取栈顶元素。返回栈顶元素，但不删除。

⑤判断栈是非为空 StackEmpty(S):判断栈是否为空。若栈为空，函数返回值为1；否则，返回值为0。

⑥判断栈是否为满 StackFull (S):判断栈是否为满。若栈已满，函数返回值为1；否则，返回值为0。

⑦销毁

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;
}

运行结果： 

十进制转二进制 

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(&amp;S, exp[i] - 48);
                break;
            case '+':
                /*出2个*/
                pop(&amp;S, &amp;op1);
                pop(&amp;S, &amp;op2);
                x = op2 + op1;
                push(&amp;S, x);
                break;
            case '*':
                pop(&amp;S, &amp;op1);
                pop(&amp;S, &amp;op2);
                x = op2 * op1;
                push(&amp;S, x);
                break;
            case '-':
                pop(&amp;S, &amp;op1);
                pop(&amp;S, &amp;op2);
                x = op2 - op1;
                push(&amp;S, x);
                break;
            case '/':
                pop(&amp;S, &amp;op1);
                pop(&amp;S, &amp;op2);
                x = op2 / op1;
                push(&amp;S, x);
                break;
        }
    }
    pop(&amp;S, &amp;x);
    printf("计算结果为：%s = %d\n", exp, x);
    destroy(&amp;S);
}

 

4.完整demo

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", &amp;cmd);
        switch (cmd) {
            case 1:
                printf("请输入栈的最大存储空间(MaxSize)：");
                scanf("%d", &amp;maxsize);
                if (!init(&amp;S, maxsize)) {
                    printf("栈已初始化！\n");
                }
                break;
            case 2:
                printf("请输入入栈元素：x=");
                scanf("%d", &amp;x);
                if (!push(&amp;S, x)) {
                    printf("元素【%d】已入栈！\n", x);

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

                break;
            case 4:
                if (!get_top(&amp;S, &amp;x)) {
                    printf("栈顶元素为：%d\n", x);
                }
                break;
            case 5:
                if (empty(&amp;S)) {
                    printf("栈为空！\n");
                } else {
                    printf("栈不为空！\n");
                }
                break;
            case 6:
                if (full(&amp;S)) {
                    printf("栈已满！\n");
                } else {
                    printf("栈未满！\n");
                }
                break;
            case 7:
                printf("确定要销毁（销毁后数据不可恢复,y|n,n）？");
                fflush(stdin);//  清空输入stdin缓冲区
                scanf("%c", &amp;yn);
                if (yn == 'y' || yn == 'Y') {
                    if (!destroy(&amp;S)) {
                        printf("销毁栈成功！\n");
                    }
                }
                break;
            case 8:
                do {
                    printf("----------8.栈的应用------------\n");
                    printf(" 1. 十进制转换为二进制\n");
                    printf(" 2. 后缀表达式计算\n");
                    printf(" 0. 返回\n");
                    printf("请选择：");
                    scanf("%d", &amp;cmd);

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

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

    } while (cmd != 0);
    return 0;
}

seqstack.c

#include "seqstack.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(&amp;S, 32);

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

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

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

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

    char exp[20]; /*后缀表达式*/
    init(&amp;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(&amp;S, exp[i] - 48);
                break;
            case '+':
                /*出2个*/
                pop(&amp;S, &amp;op1);
                pop(&amp;S, &amp;op2);
                x = op2 + op1;
                push(&amp;S, x);
                break;

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

 seqstach.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);

/* 8.十进制转二进制*/
int d_to_b(int d);

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

5.小结

萌新初学，如有错误，欢迎指出。

6.参考文献

《数据结构（C语言版）》

知乎

要什么温柔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构 顺序栈
夜雨柠檬
03-26 842
做一个豁达而努力的自己。栈的定义：只能在表的一端（栈顶）进行插入和删除的线性表。逻辑结构：与线性表相同，仍为一一对应的关系。存储结构：用顺序栈和链栈存储均可，但以顺序栈更为常见。运算规则：只能在栈顶（top）进行运算，且访问节点时只能先进后出（FILO），或后进先出（LIFO）的原则。实现方式：关键是在写压栈和弹栈的函数具体的实现依顺序栈和链栈的不同而不同，基本的操作有压栈，弹栈，读取栈顶元素，建...
数据结构--顺序栈
weixin_46203845的博客
12-02 83
#include <stdio.h> #include <stdlib.h> //预定义常量和类型 #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define STACK_INIT_SIZE 100 //存储空间分配量 #define STACKINCREMENT 10 //存储空间分配增量 typedef Status; typedef int SElemType; typedef struct{ SElemType
数据结构-顺序栈详解（C语言）
m0_55698213的博客
10-20 1691
本文主要讲述顺序栈基本定义和特点以及顺序栈的C语言代码实现与顺序栈的实际应用。以上就是顺序栈的基本介绍，本文仅仅简单介绍了顺序栈概念、特点、运算以及顺序栈的应用。顺序栈是一种特殊的线性数据结构，它遵循先进后出（FILO）的原则，即在栈顶添加和删除元素。顺序栈在计算机科学中经常使用，因为它允许我们在高频率的情况下进行添加和删除操作。
数据结构-顺序栈的基本操作（C语言实现）
热门推荐
祝星.的代码库
07-21 1万+
栈（Stack）是一种后进先出的线性表，限定这种类型的线性表为只能在某一端进行插入和删除操作。基于栈的特性，我们把它称作后进先出表（LastinFirstout）LIFO。常用术语栈顶（Top）线性表允许插入和删除的那一端。栈底不可操作的那一端。空栈不包含任何元素的空表。...
数据结构-顺序栈的基础操作
m0_52118763的博客
12-22 2077
 顺序栈是用顺序存储结构实现的栈，即利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时由于栈的操作的特殊性，还必须附设一个位置指针top（栈顶指针）来动态地指示栈顶元素在顺序栈中的位置。通常以top=0表示空栈。顺序栈的存储结构可以用C语言中的一维数组来表示。 栈的顺序存储结构定义如下： ＃define STACK_INIT_SIZE 100 ＃define STACKINCREMENT 10 ＃define TRUE 1 ＃define FALSE 0 typedef struct
漫话数据结构-顺序栈.pptx
11-03
漫话数据结构
数据结构---栈和队列之顺序栈（C语言）
05-05
数据结构----栈和队列之顺序栈（C语言），完整代码可运行
数据结构--顺序栈的基本运算.pdf
10-04
数据结构--顺序栈的基本运算.pdf
数据结构-基本算法-顺序栈
05-21
数据结构-基本算法-顺序栈(学生时代源码，调试可运行)
数据结构--顺序栈的基本运算.doc
10-06
数据结构--顺序栈的基本运算 顺序栈是一种基本的数据结构，广泛应用于计算机科学和软件开发领域。顺序栈的基本运算包括初始化顺序栈、判断顺序栈是否为空、依次进栈元素、输出栈长度、输出从栈顶到栈底的元素、读出...
插入排序和希尔排序详解
friendhan2005的博客
06-08 517
希尔排序详解，大家快来看！！！
二叉树顺序结构——堆的结构与实现
qq3304968099的博客
06-10 859
二叉树顺序结构——堆的结构与源代码实现
数据结构和算法一轮
李青水的博客
06-08 866
数据结构第一轮复习
数据结构--栈和队列
code袁的博客
06-08 861
🦁作者简介：一名喜欢分享和记录学习的在校大学生💥个人主页code袁💥个人QQ🐯个人wechat：code8896栈是一种线性数据结构，具有后进先出（LIFO）的特点。栈可以简单地理解为一摞盘子，我们只能在盘子的顶部放入或取出盘子，不能在中间插入或者从底部取出盘子。队列是一种线性数据结构，具有先进先出（FIFO）的特点。队列可以简单地理解为排队，先到先得，后到后得。手动码字，如有错误，欢迎在评论区指正💬~你的支持就是我更新的最大动力💪~
【数据结构】二叉树顺序实现（大堆）--＞赋源码
最新发布
Cayyyy的博客
06-11 2599
二叉树顺序实现
数据结构：线索二叉树
weixin_67035108的博客
06-07 464
线索二叉树（Threaded Binary Tree）是一种对普通二叉树的扩展，它通过在树的某些空指针上添加线索来实现更高效的遍历操作。线索二叉树的目的是减少查找特定节点（如前驱或后继节点）所需的时间，从而提高树的搜索效率。：每个节点的前驱是其在中序遍历中直接前的一个节点，后继是直接后的节点。线索二叉树允许我们通过线索快速找到这些节点。：在二叉树的空指针（左子树或右子树的指针）上添加线索，这些线索可以指导我们找到节点的前驱或后继。：线索二叉树是基于普通二叉树的，它保留了二叉树的所有性质。
数据结构（树）
lazy_girl_666的博客
06-07 619
原先的左子节点变成新的父节点，并把多余的右子节点出让，给已经降级的根节点当左子节点。原先的右子节点变成新的父节点，并把多余的左子节点出让，给已经降级的根节点当右节点。如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil视为叶节点，每个叶节点（Nil）是黑色的；步骤： 1） 把不平衡的点作为支点，把支点左旋降级，变成左子结点，晋升原来的右子节点。对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点。当根节点左子树的左子树有节点插入，导致二叉树不平衡。
数据结构和矩阵细节用法：double、cell和complex #matlab
m0_56619132的博客
06-08 1037
简单来说，结构矩阵的每一列为一个变量，即类似于分类变量，每个变量下的数据类型是相同的，例如姓名下的数据全是文本，学号下的数据全是数值；而单位矩阵的各个矩阵是不同的，第一行第一列是数值，第一行第二列可能是文本，第二行第一列可能又是包含n个元素的矩阵，即你可以理解为单元矩阵是“乱输一通”的的矩阵。注：在这个例子中，T是一个table，包含三列：一列是double类型的数字，一列是char类型的字母，还有一列是logical类型的标志。用“()”输出整行，用“.”和“()”结合输出具体的某行某列的元素。
考研系列-数据结构第二章、线性表
Nelson_hehe的博客
06-09 1725
本文是408考研付费专栏系列-数据结构线性表章节，本文章详细地总结了线性表的相关知识，其中包括：顺序表、链表（单链表、双链表、循环链表、静态链表等）的细节和重要知识点汇总。考研听课、复习的好帮手。
数据结构c语言-顺序栈
10-05
在C语言中，顺序栈的存储结构可以使用一个一维数组来存放栈中的元素，同时使用一个指示器top来指示栈顶的位置。在进行进栈和出栈操作时，需要更新top的值，使其指向栈顶元素。 下面是一种常见的顺序栈的定义和基本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值