详解顺序栈

已于 2023-10-22 23:17:17 修改
阅读量124 收藏
点赞数
文章标签： java 数据库 开发语言
于 2023-10-20 19:01:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjk200204/article/details/133952008
版权

一、顺序栈的定义

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

二、顺序栈的常用操作

1、初始化顺序栈

/* 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、入栈

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

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

3、出栈

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

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

	return 0;
}

4、取栈顶元素

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

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

	return 0;
}

5、栈是否为空

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

6、栈是否已满

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

7、销毁栈

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

三、顺序栈的应用

1、十进制转换为二进制




/*十进制转换为二进制*/
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);
}


/*后缀表达式计算*/
int expression()
{
	SeqStack S;
	int i;
	int op1, op2;	
	int 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 = op1 + op2;
			push(&S, x);
			break;

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

2、后缀表达式计算

/*后缀表达式计算*/
int expression()
{
	SeqStack S;
	int i;
	int op1, op2;	
	int 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 = op1 + op2;
			push(&S, x);
			break;

		case '*':
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 * op2;
			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);
            if(op1==0){
	        	printf("除数不能为零！\n");
				return 0; 
			}
	        x = op2 / op1;
	        push(&S, x);
	        break;
		}
	}
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

四、运行截图

五、完整代码

/*
	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);
/*
	seqstack.c
*/
#include <stdio.h>
#include <malloc.h>
#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;
}

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

#include "seqstack.h"

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

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

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

	int cmd;
	int d;

	DataType x;
	int maxsize;
	char yn;

	
	do
	{
        printf(●'◡'●)欢迎收看王蕊的作业
		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）？");
			flushall();
			scanf("%c", &yn);
			if(yn == 'y' || yn == 'Y')
			{
				if(!pop(&S, &x))
				{
					printf("栈顶元素【%d】已出栈！\n", x);
				}
			}

			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;
       case 9:
		    printf("本程序由王蕊设计开发，如有问题尽请指教学习);
		}
	}while(cmd!=0);
	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);
}


/*后缀表达式计算*/
int expression()
{
	SeqStack S;
	int i;
	int op1, op2;	
	int 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 = op1 + op2;
			push(&S, x);
			break;

		case '*':
			pop(&S, &op1);
			pop(&S, &op2);
			x = op1 * op2;
			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);
            if(op1==0){
	        	printf("除数不能为零！\n");
				return 0; 
			}
	        x = op2 / op1;
	        push(&S, x);
	        break;
		}
	}
		
	pop(&S, &x);
	printf("计算结果为：%s = %d\n", exp, x);
	destroy(&S);
}

六、小结

顺序栈是用顺序存储结构实现的栈，即利用各一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时由于栈操作的特殊性，还必须附设一个位置指针（栈顶指针）来动态地知识栈顶元素在顺序栈中的位置。通常以 t o p = − 1 top=-1 top=−1表示空栈。

七、参考资料

1、谭浩强编著，C程序设计

2、《C程序设计（第二版）》，谭浩强编

3、季老师代码

头的小豆包
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
详解单调栈算法
Gene_I must wait for the sunrise
03-17 7142
前言 如果你对这篇文章可感兴趣，可以点击「【访客必读 - 指引页】一文囊括主页内所有高质量博客」，查看完整博客分类与对应链接。 栈属于基础数据结构之一，基础到仅用「后进先出」这四个字即可完整概括其核心特征。然而，基础并不代表着简单，「后进先出」的背后反而隐藏着多样的变化与极其广泛的应用。 在本篇文章中，我们将针对在基础栈上稍加改动所形成的「单调栈」算法进行详解。该算法与「单调队列」组成了算法题中最常考察的线性数据结构，属于面试中必知必会的算法知识。 栈 首先我们来回忆一下「栈」。「栈」是一种「后进先出」的线
顺序栈 C++
05-09
顺序栈 C++ 实现详解 顺序栈是计算机科学中的一种基本数据结构，它是一种先进先出（First-In-First-Out，FIFO）的数据结构。下面我们将详细介绍顺序栈的 C++ 实现。 顺序栈的定义 顺序栈（Sequential Stack）是一...
栈详解 顺序栈 基本操作 C语言实现 数据结构
weixin_63666347的博客
05-14 1162
一、栈 1.1栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底，栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则 1.2栈的实现 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些，因为数组在尾上插入数据的代价比较小 顺序栈基本操作 #include<stdio.h> #include<stdlib.h> #incl..
顺序栈的详解
qq_54938554的博客
10-19 1748
栈是一种特殊的数据结构，它的特点是后进先出（Last In First Out，LIFO）。栈是一种线性结构，它可以用来存储一组具有相同类型的数据元素。栈的基本操作包括压入（push）和弹出（pop），其中压入操作将数据元素添加到栈的顶部，弹出操作将栈顶的数据元素移除并返回。/* 堆空间 */int top;/* 栈顶指针 */}SeqStack;/* 1. 初始化 *//* 2. 进（入）栈 *//* 3. 出栈 *//* 4. 取栈顶元素 *//* 5. 栈为空？*/
栈详解（顺序栈和链栈）
o8699458的博客
08-08 1440
栈什么是栈？顺序栈链栈 什么是栈？ 栈是一种基本数据结构，因其拥有后进先出的特点（Last in First out），也就是LIFO，栈的一种常见用途就是用来判断一串字符中的括号是否有效。 括号的类型有{}、[]、()，“{[]}”像这样的就是有效的，而像"{[])"这样的就是无效的括号，这通常用于编译器的语法检查。 在内存的中使用也是一种栈，因函数调用会压栈，每调用一次压栈一次，当递归层次太深时，我们经常看到编译器报错：“Stack Overflow”,也就是栈溢出。 栈的主要操作有Push和Pop，入
数据结构——顺序栈详解
最新发布
weixin_51785373的博客
10-20 1738
1、栈：特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则2、初始化栈（init）：创建一个空栈，把栈顶指针设为-1.3、入栈（Push)：插入元素到栈顶元素的操作4、出栈(pop)：从栈顶删除最后一个元素的操作5、判断是否为空：检查栈顶指针是否指向存储空间的起始位置top为-1。
详解栈和队列（顺序栈）
qq_61514490的博客
03-27 1195
同顺序表和链表一样，栈也是用来存储逻辑关系为 "一对一" 数据的链式存储结构，如图 1 所示。 图 1 栈存储结构示意图 从图 1 我们看到，栈存储结构与之前所学的线性存储结构有所差异，这缘于栈对数据 "存" 和 "取" 的过程有特殊的要求： 栈只能从表的一端存取数据，另一端是封闭的，如图 1 所示； 在栈中，无论是存数据还是取数据，都必须遵循"先进后出"的原则，即最先进栈的元素最后出栈。拿图 1 的栈来说，从图中数据的存储状态可判断出，元素 1 是最先进的栈。因此，当需要从栈中取出元素 .
数据结构-顺序栈详解（C语言）
m0_55698213的博客
10-20 1743
本文主要讲述顺序栈基本定义和特点以及顺序栈的C语言代码实现与顺序栈的实际应用。以上就是顺序栈的基本介绍，本文仅仅简单介绍了顺序栈概念、特点、运算以及顺序栈的应用。顺序栈是一种特殊的线性数据结构，它遵循先进后出（FILO）的原则，即在栈顶添加和删除元素。顺序栈在计算机科学中经常使用，因为它允许我们在高频率的情况下进行添加和删除操作。
顺序栈 详解
有梦的博客
09-19 1288
在学习栈和队列之前你需要对他们已经有了，一定的了解比如 stack先进后出  queue 先进先出 1、下面我们学习顺序栈(其实和顺序链表一个原理)  对于这里的SElemType 就是一种数据的类型 ，它可以int 型，这里我想说一下它可以是 结构体，所以base 就是一个指向结构体的指针，我们可以通过base进行对结构体中的数据 访问和修改,如果还是不懂那就看我关于链表的介绍，那
栈结构之顺序栈详解（C语言版）
热门推荐
qq_44075108的博客
10-24 1万+
本文对栈结构的顺序栈进行详解并使用C语言对顺序栈进行实现，文章的主要内容包括顺序栈的定义、顺序栈的结构以及顺序栈的常用操作
栈的四则运算实现及详解
05-15
c语言数据结构栈的四则运算（带括号）的实现，里面有解释
栈和队列详解
06-17
"栈和队列详解" 栈和队列是数据结构中两个基本的数据结构概念，本文将详细介绍栈和队列的定义、原理、操作和应用。 栈的定义和原理 栈是一种后进先出（Last-In-First-Out，LIFO）的数据结构，栈中的元素按照加入...
JavaScript实现栈结构Stack过程详解
10-15
对于给定的栈操作练习，我们需要根据栈的LIFO特性来判断出栈顺序的合法性。例如，C选项中，3出栈后应为4，但题目给出了6，所以C是非法的。其他选项均符合栈的出栈规则，因此是合法的。 总之，理解栈的原理和实现...
C语言栈的表示与实现实例详解
09-04
栈在C语言中的表示通常使用数组或链表实现，这里我们将主要关注基于数组的顺序栈。 1. 基本概念： 栈是一种线性数据结构，其特点是只允许在表的一端，也就是栈顶进行插入（Push）和删除（Pop）操作。栈底是固定的，...
C语言实现静态顺序表的实例详解
08-29
C语言实现静态顺序表的实例详解 在计算机科学中，顺序表是一种基本的数据结构，它是由一系列元素组成的有序集合。静态顺序表是一种特殊的顺序表，它在内存中开辟了一段连续的存储空间，并给它一个名字进行标识。...
数据结构 栈的操作实例详解
08-30
栈可以用数组或链表来实现，在这里我们将使用顺序栈来实现。顺序栈的定义如下： ```c typedef struct { ElemType *elem; // 存储空间的基址 int top; // 栈顶元素的下一个元素，简称栈顶位标 int size; // 当前...
JavaScript栈和队列相关操作与实现方法详解
10-17
JavaScript中的栈和队列是两种基础且重要的数据结构，它们在处理数据的顺序和访问方式上有着明显的区别。栈遵循“后进先出”（LIFO）原则，而队列则遵循“先进先出”（FIFO）原则。 **栈（Stack）** 栈是一种线性...
详解Spring Boot 配置加载顺序及属性加载顺序
08-27
Spring Boot 配置加载顺序及属性加载顺序详解 Spring Boot 是一个流行的 Java 框架，用于快速构建基于 Spring 的应用程序。在 Spring Boot 中，配置加载顺序及属性加载顺序是一个非常重要的概念。我们可以通过多种...
c++ linked stack详解
03-28
Linked stack是一种基于链表实现的栈数据结构，它和顺序栈不同，顺序栈是基于数组实现的，Linked stack是基于链表实现的。这也是它和顺序栈的最大区别。 Linked stack的实现主要依靠链表的基本操作，包括插入、删除...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值